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

namespace IStation.BLL
{
    /// <summary>
    /// 测点
    /// </summary>
    public partial class MonitorPoint
    {
        private readonly IDAL.IMonitorPoint<Entity.MonitorPoint> _dal
        = DAL.Factory.DataAccess.CreateDAL<IDAL.IMonitorPoint<Entity.MonitorPoint>>(Settings.DataAccess.MonitorDLLName, Settings.DataAccess.DALNameSpace);

        #region Cache 

        //根据 projectId 查询缓存
        private List<Model.MonitorPoint> GetProjectCache(long projectId)
        {
            return MonitorPointCacheHelper.GetSet(projectId, () =>
            {
                var entities = _dal.GetAll(projectId);
                var models = Entity2Models(entities);
                if (models == null)
                {
                    models = new List<Model.MonitorPoint>();
                }
                return models;
            }, ConfigHelper.CacheKeepTime, ConfigHelper.CacheRandomTime);
        }

        //根据 Id 更新缓存
        private void UpdateProjectCache(long projectId, long Id)
        {
            var entity_ds = _dal.GetById(projectId, Id);
            var model_ds = Entity2Model(entity_ds);
            var all = GetProjectCache(projectId);
            var model = all.Find(x => x.Id == Id);
            if (model == null)
            {
                all.Add(model_ds);
            }
            else
            {
                model.Reset(model_ds);
            }
        }

        //根据 Ids 更新缓存
        private void UpdateProjectCache(long projectId, IEnumerable<long> Ids)
        {
            if (Ids == null || Ids.Count() < 1)
                return;
            var entities = _dal.GetByIds(projectId, Ids);
            var models = Entity2Models(entities);
            var all = GetProjectCache(projectId);
            all.RemoveAll(x => Ids.Contains(x.Id));
            if (models != null && models.Count > 0)
            {
                all.AddRange(models);
            }
        }

        //根据 Id 移除缓存
        private void RemoveProjectCache(long projectId, long Id)
        {
            var all = GetProjectCache(projectId);
            all.RemoveAll(x => x.Id == Id);
        }

        #endregion

        #region Get 

        #region 测点


        /// <summary>
        /// 查询全部
        /// </summary>
        public List<Model.MonitorPoint> GetAll(long projectId)
        {
            var all = GetProjectCache(projectId);
            return all.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 Id查询
        /// </summary>
        public Model.MonitorPoint GetById(long projectId, long Id)
        {
            var all = GetAll(projectId);
            return all.Find(x => x.Id == Id);
        }

        /// <summary>
        /// 根据 Ids 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByIds(long projectId, IEnumerable<long> Ids)
        {
            if (Ids == null || Ids.Count() < 1)
                return default;
            var all = GetAll(projectId);
            return all.Where(x => Ids.Contains(x.Id)).ToList();
        }

        /// <summary>
        /// 根据 Ids 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByIds
            (long projectId, IEnumerable<long> ids, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            if (ids == null || ids.Count() < 1)
                return default;
            var all = GetProjectCache(projectId);
            all = all.Where(x => ids.Contains(x.Id) && x.MonitorType == monitorType && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByBelongTypeAndBelongId(long projectId, string belongType, long belongId)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.BelongType == belongType && x.BelongId == belongId).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.eMonitorType monitorType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.BelongType == belongType && x.BelongId == belongId && x.MonitorType == monitorType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByBelongTypeAndBelongId
          (long projectId, string belongType, long belongId, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.BelongType == belongType && x.BelongId == belongId && x.MonitorType == monitorType && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.Monitor.eCronType cronType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.BelongType == belongType && x.BelongId == belongId && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 BelongType 和 BelongIds 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByBelongTypeAndBelongIds(long projectId, string belongType, IEnumerable<long> belongIds)
        {
            if (belongIds == null || belongIds.Count() < 1)
                return default;
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.BelongType == belongType && belongIds.Contains(x.BelongId)).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 groupId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByGroupId(long projectId, long groupId)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.GroupId == groupId).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 groupId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByGroupId
            (long projectId, long groupId, Model.eMonitorType monitorType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.GroupId == groupId && x.MonitorType == monitorType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 groupId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByGroupId
            (long projectId, long groupId, Model.Monitor.eCronType cronType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.GroupId == groupId && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 groupId 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByGroupId
            (long projectId, long groupId, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.GroupId == groupId && x.MonitorType == monitorType && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 groupIds 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByGroupIds(long projectId, IEnumerable<long> groupIds)
        {
            if (groupIds == null || groupIds.Count() < 1)
                return default;
            var all = GetProjectCache(projectId);
            all = all.Where(x => groupIds.Contains(x.GroupId)).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 groupIds 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByGroupIds
            (long projectId, IEnumerable<long> groupIds, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            if (groupIds == null || groupIds.Count() < 1)
                return default;
            var all = GetProjectCache(projectId);
            all = all.Where(x => groupIds.Contains(x.GroupId) && x.MonitorType == monitorType && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        /// <summary>
        /// 根据 MonitorType 和 CronType 查询
        /// </summary>
        public List<Model.MonitorPoint> GetByMonitorTypeAndCronType
            (long projectId, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            var all = GetProjectCache(projectId);
            all = all.Where(x => x.MonitorType == monitorType && x.CronType == cronType).ToList();
            return all?.OrderBy(x => x.SortCode).ToList();
        }

        #endregion

        #region 测点+信号列表

        /// <summary>
        /// 查询所有
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalList(long projectId)
        {
            var allMonitorList = GetAll(projectId);
            if (allMonitorList == null || allMonitorList.Count() < 1)
                return default;
            var allSignalList = new Signal().GetAll(projectId);
            if (allSignalList == null || allSignalList.Count() < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByBelongTypeAndBelongId(long projectId, string belongType, long belongId)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.eMonitorType monitorType)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId, monitorType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId, monitorType, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongIds 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByBelongTypeAndBelongIds(long projectId, string belongType, IEnumerable<long> belongIds)
        {
            if (belongIds == null || belongIds.Count() < 1)
                return default;
            var allMonitorList = GetByBelongTypeAndBelongIds(projectId, belongType, belongIds);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 groupId 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByGroupId(long projectId, long groupId)
        {
            var allMonitorList = GetByGroupId(projectId, groupId);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupIds 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByGroupIds(long projectId, IEnumerable<long> groupIds)
        {
            if (groupIds == null || groupIds.Count() < 1)
                return default;
            var allMonitorList = GetByGroupIds(projectId, groupIds);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 id 查询
        /// </summary>
        public Model.MonitorPointExSignalList GetExSignalListById(long projectId, long id)
        {
            var monitor = GetById(projectId, id);
            if (monitor == null)
                return default;
            var signalList = new Signal().GetByMonitorPointId(projectId, id);
            if (signalList == null || signalList.Count < 1)
                return default;
            return new Model.MonitorPointExSignalList(monitor, signalList);
        }

        /// <summary>
        /// 根据 ids 查询
        /// </summary>
        public List<Model.MonitorPointExSignalList> GetExSignalListByIds(long projectId, IEnumerable<long> ids)
        {
            if (ids == null || ids.Count() < 1)
                return default;
            var allMonitorList = GetByIds(projectId, ids);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id));
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPointExSignalList>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPointExSignalList(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        #endregion

        #region 测点+信号+信号类型

        /// <summary>
        /// 根据 Id 查询
        /// </summary>
        public Model.MonitorPoint_Signal_SignalType GetExSignalWithSignalTypeById
            (long projectId, long id)
        {
            var monitor = GetById(projectId, id);
            if (monitor == null)
                return default;
            var signalList = new Signal().GetExSignalTypeByMonitorPointId(projectId, monitor.Id);
            if (signalList == null || signalList.Count() < 1)
                return default;
            var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
            return vm;
        }

        /// <summary>
        /// 根据 Ids 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByIds
            (long projectId, IEnumerable<long> ids)
        {
            if (ids == null || ids.Count() < 1)
                return default;
            var allMonitorList = GetByIds(projectId, ids);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 Ids 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByIds
            (long projectId, IEnumerable<long> ids, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            if (ids == null || ids.Count() < 1)
                return default;
            var allMonitorList = GetByIds(projectId, ids, monitorType, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupId 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByGroupId
            (long projectId, long groupId)
        {
            var allMonitorList = GetByGroupId(projectId, groupId);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupId 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByGroupId
            (long projectId, long groupId, Model.eMonitorType monitorType)
        {
            var allMonitorList = GetByGroupId(projectId, groupId, monitorType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupId 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByGroupId
            (long projectId, long groupId, Model.Monitor.eCronType cronType)
        {
            var allMonitorList = GetByGroupId(projectId, groupId, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupId 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByGroupId
            (long projectId, long groupId, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            var allMonitorList = GetByGroupId(projectId, groupId, monitorType, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupIds 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByGroupIds
            (long projectId, IEnumerable<long> groupIds)
        {
            if (groupIds == null || groupIds.Count() < 1)
                return default;
            var allMonitorList = GetByGroupIds(projectId, groupIds);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 GroupIds 查询
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByGroupIds
            (long projectId, IEnumerable<long> groupIds, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            if (groupIds == null || groupIds.Count() < 1)
                return default;
            var allMonitorList = GetByGroupIds(projectId, groupIds, monitorType, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询 测点+信号+信号类型
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询 测点+信号+信号类型
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.eMonitorType monitorType)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId, monitorType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询 测点+信号+信号类型
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.Monitor.eCronType cronType)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }

        /// <summary>
        /// 根据 BelongType 和 BelongId 查询 测点+信号+信号类型
        /// </summary>
        public List<Model.MonitorPoint_Signal_SignalType> GetExSignalWithSignalTypeByBelongTypeAndBelongId
            (long projectId, string belongType, long belongId, Model.eMonitorType monitorType, Model.Monitor.eCronType cronType)
        {
            var allMonitorList = GetByBelongTypeAndBelongId(projectId, belongType, belongId, monitorType, cronType);
            if (allMonitorList == null || allMonitorList.Count < 1)
                return default;
            var allSignalList = new Signal().GetExSignalTypeByMonitorPointIds(projectId, allMonitorList.Select(x => x.Id).Distinct());
            if (allSignalList == null || allSignalList.Count < 1)
                return default;
            var vmList = new List<Model.MonitorPoint_Signal_SignalType>();
            foreach (var monitor in allMonitorList)
            {
                var signalList = allSignalList.Where(x => x.MonitorPointId == monitor.Id).OrderBy(x => x.SortCode).ToList();
                if (signalList.Count < 1)
                    continue;
                var vm = new Model.MonitorPoint_Signal_SignalType(monitor, signalList);
                vmList.Add(vm);
            }
            return vmList;
        }


        #endregion

        #endregion

        #region Insert

        /// <summary>
        /// 插入
        /// </summary>
        public long Insert(long projectId, Model.MonitorPoint model)
        {
            if (projectId < 1)
                return default;
            if (model == null)
                return default;
            var entities = Model2Entity(model);
            var Id = _dal.Insert(projectId, entities);
            if (Id > 0)
            {
                UpdateProjectCache(projectId, Id);
            }
            return Id;
        }

        /// <summary>
        /// 批量插入
        /// </summary>
        public bool Inserts(long projectId, IEnumerable<Model.MonitorPoint> list)
        {
            if (projectId < 1)
                return default;
            if (list == null || list.Count() < 1)
                return default;
            var entities = Model2Entities(list.ToList());
            var Ids = _dal.InsertsR(projectId, entities);
            if (Ids != null && Ids.Count > 0)
            {
                UpdateProjectCache(projectId, Ids);
                return true;
            }
            return false;
        }

        #endregion

        #region Update

        /// <summary>
        /// 更新
        /// </summary>
        public bool Update(long projectId, Model.MonitorPoint model)
        {
            if (projectId < 1)
                return default;
            if (model == null)
                return default;
            if (model.Id < 1)
                return default;
            var entities = Model2Entity(model);
            var bol = _dal.Update(projectId, entities);
            if (bol)
            {
                UpdateProjectCache(projectId, model.Id);
            }
            return bol;
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        public bool Updates(long projectId, List<Model.MonitorPoint> list)
        {
            if (projectId < 1)
                return default;
            if (list == null || list.Count() < 1)
                return default;
            if (list.ToList().Exists(x => x.Id < 1))
                return default;
            var entities = Model2Entities(list.ToList());
            var bol = _dal.Updates(projectId, entities);
            if (bol)
            {
                UpdateProjectCache(projectId, list.Select(x => x.Id).ToList());
            }
            return bol;
        }

        #endregion

        #region Exist

        /// <summary>
        /// 根据 Id 判断是否存在
        /// </summary>
        public bool IsExistById(long projectId, long Id)
        {
            var all = GetAll(projectId);
            return all.Exists(x => x.Id == Id);
        }
        #endregion

        #region Delete

        /// <summary>
        /// 根据 Id 删除
        /// </summary>
        public bool DeleteById(long projectId, long Id, out string msg)
        {
            msg = string.Empty;
            var bol = _dal.DeleteById(projectId, Id);
            if (bol)
            {
                RemoveProjectCache(projectId, Id);
            }
            return bol;
        }

        #endregion 

        #region Cover

        /// <summary>
        /// 批量覆盖
        /// </summary>
        public bool Covers(long projectId, IEnumerable<Model.MonitorPoint> list)
        {
            if (projectId < 1)
                return default;
            if (list == null || list.Count() < 1)
                return default;
            var entities = Model2Entities(list.ToList());
            var bol = _dal.Covers(projectId, entities);
            if (bol)
            {
                MonitorPointCacheHelper.Remove(projectId);
            }
            return bol;
        }

        /// <summary>
        /// 批量覆盖并返回
        /// </summary> 
        public List<Entity.MonitorPoint> CoversR(long projectId, IEnumerable<Model.MonitorPoint> list)
        {
            if (projectId < 1)
                return default;
            if (list == null || list.Count() < 1)
                return default;
            var entities = Model2Entities(list.ToList());
            var models = _dal.CoversR(projectId, entities);
            if (models != null && models.Count > 0)
            {
                MonitorPointCacheHelper.Remove(projectId);
            }
            return models;
        }

        /// <summary>
        /// 覆盖
        /// </summary>
        public bool CoverEx(long projectId, IEnumerable<Model.MonitorPointExSignalList> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            if (list.ToList().Exists(x => x.SignalList == null || x.SignalList.Count < 1))
                return default;

            var monitorPints = new List<Model.MonitorPoint>();
            var signals = new List<Model.Signal>();

            var dict = new Dictionary<Model.MonitorPoint, IEnumerable<Model.Signal>>();
            foreach (var item in list)
            {
                monitorPints.Add(item);
                signals.AddRange(item.SignalList);
            }

            if (!(Covers(projectId, monitorPints) && new Signal().Covers(projectId, signals)))
            {
                return false;
            }
            MonitorPointCacheHelper.Remove(projectId);
            SignalCacheHelper.Remove(projectId);
            return true;
        }

        #endregion




    }
}