IStation/Service.V4.1.git

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace IStation.Service
{
    /// <summary>
    /// 能效(多)实时记录
    /// </summary>
    public partial class EtaMultiRealRecord
    {
 
        #region Query
 
        /// <summary>
        /// 通过 CorpID 获取某日的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetByCorpIDOfDay(long CorpID, DateTime Day)
        {
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetByCorpIDOfDay(CorpID,  Day); 
            var model_list = Entity2Models(entity_list);
            return model_list?.OrderBy(x => x.DataTime).ToList();
        }
 
        /// <summary>
        /// 通过对象获取某日的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetByObjectOfDay(long CorpID, string ObjectType, long ObjectID, DateTime Day)
        {
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetByObjectOfDay(CorpID, ObjectType, ObjectID, Day);
            var model_list = Entity2Models(entity_list);
            return model_list?.OrderBy(x => x.DataTime).ToList();
        }
 
        /// <summary>
        /// 通过对象获取某日运行的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetRunByObjectOfDay(long CorpID, string ObjectType, long ObjectID, DateTime Day)
        {
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunByObjectOfDay(CorpID, ObjectType, ObjectID, Day);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过对象获取日期区间内的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetByObjectOfDayRange(long CorpID, string ObjectType, long ObjectID, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetByObjectOfDayRange(CorpID, ObjectType, ObjectID, StartDay.Date, EndDay.Date);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过对象获取日期区间内运行的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetRunByObjectOfDayRange(long CorpID, string ObjectType, long ObjectID, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunByObjectOfDayRange(CorpID, ObjectType, ObjectID, StartDay.Date, EndDay.Date);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过对象获取时间区间内的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetByObjectOfTimeRange(long CorpID, string ObjectType, long ObjectID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetByObjectOfTimeRange(CorpID, ObjectType, ObjectID, StartTime, EndTime);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过对象获取时间区间内运行的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetRunByObjectOfTimeRange(long CorpID, string ObjectType, long ObjectID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunByObjectOfTimeRange(CorpID, ObjectType, ObjectID, StartTime, EndTime);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过对象获取日期流量扬程区间内运行的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetRunByObjectOfQHDayRange 
            (long CorpID, string ObjectType, long ObjectID, DateTime StartDay, DateTime EndDay, double Qmin, double Qmax, double Hmin, double Hmax)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunByObjectOfQHDayRange(CorpID, ObjectType, ObjectID, Qmin, Qmax, Hmin, Hmax, StartDay.Date, EndDay.Date);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        ///  获取对象日期、流量、扬程区间内运行的汇总内容数据
        /// </summary>
        public List<Model.EtaMultiRunSummaryContent> GetRunSummaryContentByObjectOfQHDayRange
             (long CorpID, string ObjectType, long ObjectID, double Qmin, double Qmax, double Hmin, double Hmax, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunSummaryContentByObjectOfQHDayRange(CorpID, ObjectType, ObjectID, Qmin, Qmax, Hmin, Hmax, StartDay.Date, EndDay.Date);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过对象和运行标志获取日期区间内的数据
        /// </summary>
        public List<Model.EtaMultiRealRecord> GetByObjectAndRunningFlagOfDayRange(long CorpID, string ObjectType, long ObjectID, List<int> RunningFlag, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetByObjectAndRunningFlagOfDayRange(CorpID, ObjectType, ObjectID, RunningFlag, StartDay.Date, EndDay.Date);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 通过日期区间及频率限制集合获取并行QHP
        /// </summary>
        public List<Model.EtaQHP> GetRunQHPByRunningFlagAndHZOfDayRange 
            (long CorpID, string ObjectType, long ObjectID, List<int> RunningFlag, IEnumerable<Model.EtaHZIndexLimiter> HzLimiters, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunQHPByRunningFlagAndHZOfDayRange(CorpID, ObjectType, ObjectID, RunningFlag, Model2Entities(HzLimiters?.ToList()),StartDay.Date, EndDay.Date);
            var model_list = Entity2Models(entity_list);
            return model_list;
        }
 
        /// <summary>
        /// 获取流量扬程区间的运行时间和平均效率
        /// </summary>
        public List<Model.EtaQHETRect> GetRunQHETRectByObjectOfDayRange
            (long CorpID, string ObjectType, long ObjectID, double Qspace, double Hspace, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            if (Qspace <= 0 || Hspace <= 0)
                return default;
 
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunQHETByObjectOfDayRange(CorpID, ObjectType, ObjectID, StartDay, EndDay);
            if (entity_list == null || entity_list.Count < 1)
                return default;
 
            //流量最小值
            var min_double_q = entity_list.Min(x => x.Q);
            int q_min = 0;
            if (min_double_q > 10000)
                q_min = (int)(Math.Floor((min_double_q / 10000)) * 10000);
            else if (min_double_q > 1000)
                q_min = (int)(Math.Floor((min_double_q / 1000)) * 1000);
            else if (min_double_q > 100)
                q_min = (int)(Math.Floor((min_double_q / 100)) * 100);
            else
                q_min = (int)(Math.Floor((min_double_q / Qspace)) * Qspace);
 
 
 
            //流量最大值
            int q_max = (int)Math.Ceiling(entity_list.Max(x => x.Q));
 
 
            //扬程最大值
            int h_max = (int)Math.Ceiling(entity_list.Max(x => x.H));
            //扬程最小值
            int h_min = (int)Math.Floor(entity_list.Min(x => x.H));
 
            //流量小数位数
            var q_digit = 1;
            //扬程小数位数
            var h_digit = 2;
 
            var list = new List<Model.EtaQHETRect>();
 
            double q_temp = q_min;
            while (q_temp < q_max)
            {
                double q_temp_over = Math.Round(q_temp + Qspace, q_digit);
                if (q_temp_over > q_max)
                    q_temp_over = q_max;
 
                double h_temp = h_min;
                while (h_temp < h_max)
                {
                    double h_temp_over = Math.Round(h_temp + Hspace, h_digit);
                    if (h_temp_over > h_max)
                        h_temp_over = h_max;
 
                    var items = entity_list.Where(t => t.H >= h_temp && t.H <= h_temp_over && t.Q >= q_temp && t.Q <= q_temp_over).ToList();
 
                    var model = new Model.EtaQHETRect();
                    model.Hmax = h_temp_over;
                    model.Hmin = h_temp;
                    model.Qmax = q_temp_over;
                    model.Qmin = q_temp;
                    if (items.Count > 0)
                    {
                        model.Tsum = items.Sum(t => t.T);
                        model.Eavg = Math.Round(items.Average(t => t.E), 2);
                    }
                    list.Add(model);
 
                    h_temp = h_temp_over;
                }
 
                q_temp = q_temp_over;
            }
 
            return list;
        }
 
        /// <summary>
        /// 获取流量扬程区间的运行时间和平均效率
        /// </summary>
        public Model.EtaQHETRectList GetRunQHETRectListByObjectOfDayRange
            (long CorpID, string ObjectType, long ObjectID, double Qspace, double Hspace, DateTime StartDay, DateTime EndDay)
        {
            if (EndDay.Date < StartDay.Date)
                return default;
            if (Qspace <= 0 || Hspace <= 0)
                return default;
 
            var dal = new DAL.EtaMultiRealRecord();
            var entity_list = dal.GetRunQHETByObjectOfDayRange(CorpID, ObjectType, ObjectID, StartDay, EndDay);
            if (entity_list == null || entity_list.Count < 1)
                return default;
 
            var list = new Model.EtaQHETRectList();
 
            //流量最大值
            int q_max = (int)Math.Ceiling(entity_list.Max(x => x.Q));
            //流量最小值
            int q_min = (int)Math.Floor(entity_list.Min(x => x.Q));
 
            //扬程最大值
            int h_max = (int)Math.Ceiling(entity_list.Max(x => x.H));
            //扬程最小值
            int h_min = (int)Math.Floor(entity_list.Min(x => x.H));
 
            //流量小数位数
            var q_digit = 1;
            //扬程小数位数
            var h_digit = 2;
 
            list.Qmax = q_max;
            list.Qmin = q_min;
            list.Hmax = h_max;
            list.Hmin = h_min;
            list.Qspace = Qspace;
            list.Hspace = Hspace;
 
            double q_temp = q_min;
            while (q_temp < q_max)
            {
                double q_temp_over = Math.Round(q_temp + Qspace, q_digit);
                if (q_temp_over > q_max)
                    q_temp_over = q_max;
 
                double h_temp = h_min;
                while (h_temp < h_max)
                {
                    double h_temp_over = Math.Round(h_temp + Hspace, h_digit);
                    if (h_temp_over > h_max)
                        h_temp_over = h_max;
 
                    var items = entity_list.Where(t => t.H >= h_temp && t.H <= h_temp_over && t.Q >= q_temp && t.Q <= q_temp_over).ToList();
                    if (items.Count > 0)
                    {
                        var model = new Model.EtaQHETRect();
                        model.Hmax = h_temp_over;
                        model.Hmin = h_temp;
                        model.Qmax = q_temp_over;
                        model.Qmin = q_temp;
                        model.Tsum = items.Sum(t => t.T);
                        model.Eavg = Math.Round(items.Average(t => t.E), 2);
                        list.RectList.Add(model);
                    }
 
                    h_temp = h_temp_over;
                }
 
                q_temp = q_temp_over;
            }
 
            return list;
        }
 
        #endregion
 
        #region Insert
 
        /// <summary>
        /// 插入一条
        /// </summary>
        public long InsertLastRecord(Model.EtaMultiRealRecordPure model)
        {
            if (model == null)
                return default;
            var dal=new DAL.EtaMultiRealRecord();
            var entity = Model2Entity(model);
            var id = dal.Insert(entity);
            if (id > 0)
            {
                var redisCache = new RedisCache.EtaRealRecord();
                redisCache.SetLastMultiRecord(model);
            }
            return id;
        }
 
        /// <summary>
        /// 批量插入
        /// </summary>
        public bool InsertsLastRecord(IEnumerable<Model.EtaMultiRealRecordPure> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var dal=new DAL.EtaMultiRealRecord();
            var entity_list = Model2Entities(list.ToList());
            var bol = dal.Inserts(entity_list);
            if (bol)
            {
                var redisCache = new RedisCache.EtaRealRecord();
                redisCache.SetLastMultiRecord(list);
            }
            return bol;
        }
 
        #endregion
 
        #region Last
 
        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastMultiRecord(CorpID, ObjectType, ObjectID);
        }
 
        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastMultiRecord(CorpID, ObjectType, ObjectIds);
        }
 
        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastMultiRecord(CorpID, list);
        }
 
        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastNormalRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastNormalMultiRecord(CorpID, ObjectType, ObjectID);
        }
 
        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastNormalRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastNormalMultiRecord(CorpID, ObjectType, ObjectIds);
        }
 
        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastNormalRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastNormalMultiRecord(CorpID, list);
        }
 
        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastAbnormalRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastAbnormalMultiRecord(CorpID, ObjectType, ObjectID);
        }
 
        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastAbnormalRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastAbnormalMultiRecord(CorpID, ObjectType, ObjectIds);
        }
 
        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastAbnormalRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastAbnormalMultiRecord(CorpID, list);
        }
 
        /// <summary>
        /// 获取最后一条运行记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastRunRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastRunMultiRecord(CorpID, ObjectType, ObjectID);
        }
 
        /// <summary>
        /// 获取最后一条运行记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastRunRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastRunMultiRecord(CorpID, ObjectType, ObjectIds);
        }
 
        /// <summary>
        /// 获取最后一条运行记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastRunRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var redisCache = new RedisCache.EtaRealRecord();
            return redisCache.GetLastRunMultiRecord(CorpID, list);
        }
 
        #endregion
    }
}