SHJX_cod/SHJX.Service.Control/DataCentre.cs

using System;
using System.Linq;
using SHJX.Service.Dao;
using SHJX.Service.Model.Dao;
using SHJX.Service.Common.Model;
using SHJX.Service.ServerClient;
using System.Collections.Generic;
using SHJX.Service.Common.Extend;
using SHJX.Service.Common.Camera;
using SHJX.Service.Common.ReadXML;
using SHJX.Service.Control.Modules;
using SHJX.Service.Control.ControlProxy;
using SHJX.Service.Control.PortOperate.Content;
using SHJX.Service.Common.Logging;
using Microsoft.Extensions.Logging;

namespace SHJX.Service.Control
{
    public static class DataCentre
    {
        private static CreatGraber _graber;
        private static CreatGraber _graber2;
        private static OptClient _optClient;
        private static ReadConfigUtil _config;
        private static LiquidDropArgs _dropArgs;
        private static LiquidDropArgs _dropArgs2;
        public static OperateDataManager _dataManager;
        private static ProxyRouteContext _proxyContent;
        private static TimerController _timerController;
        private static PumpContent _pumpContent;
        private static StorageContent _storageContent;
        private static List<Routes> _routes;
        private static List<Step> _steps;
        private static List<RouteStep> _routeSteps;
        private readonly static object obj_area_lock = new();
        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(DataCentre));
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="config">配置</param>
        /// <param name="log">日志</param>
        public static void InitBaseData(ReadConfigUtil config,out int cameraNum)
        {
            try
            {
                _config = config;
                _dataManager = new(_config);
                _proxyContent = new(_config);
                _optClient = new( _config);
                _graber = new(_config.LogiCamera1, out int ret1);
                _graber2 = new(_config.LogiCamera2, out int ret2);
                _dropArgs = new(_graber.WebCam, _graber.Graber);
                _dropArgs2 = new(_graber2.WebCam, _graber2.Graber);

                cameraNum = ret1 + ret2;
                if (_config.LogiCamera1 == _config.LogiCamera2 && cameraNum==2)
                { 
                    cameraNum = 1;
                    _graber2 = _graber;
                    _dropArgs2 = _dropArgs;
                }
                _pumpContent = new(_optClient);
                _storageContent = new(_optClient);
                InitBasementData(_dataManager);
                _timerController = new( _config);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
                cameraNum = 0;
            }
        }

        /// <summary>
        /// 初始化基础数据
        /// </summary>
        /// <param name="dataManager"></param>
        private static void InitBasementData(OperateDataManager dataManager)
        {
            _routes = dataManager.Query<Routes>().ToList();
            _routeSteps = dataManager.Query<RouteStep>().ToList();
            _steps = dataManager.Query<Step>().ToList();
        }
        public static int getDigestionPositionCount()
        {
            int rtn = _dataManager.Query<EquipmentArea>().Count(item => item.AreaName.Equals("DigestionPosition") && item.Status == true);
            return rtn;
        }

        public static ReadConfigUtil GetConfig => _config;
        public static OptClient GetClient => _optClient;
        public static TimerController GetTimer => _timerController;
        public static PumpContent GetPumpContent => _pumpContent;
        public static StorageContent GetStorageContent => _storageContent;
        public static List<EquipmentMotor> GetMotor => _dataManager.Query<EquipmentMotor>().ToList();
        public static List<EquipmentArea> GetAreas => _dataManager.Query<EquipmentArea>().ToList();
        public static List<EquipmentStatus> GetEquipmentStatuses => _dataManager.Query<EquipmentStatus>().ToList();
        public static List<HeatingSetting> GetLiquidHeatings => _dataManager.Query<HeatingSetting>().ToList();
        public static TitrationValue GetBalanceValue => _dataManager.Query<TitrationValue>().First();
        public static List<RouteStep> GetRouteSteps => _routeSteps;
        public static List<Routes> GetRoutes => _routes;
        public static List<Step> GetSteps => _steps;
        public static WebCamera GetCamera => _graber.WebCam;
        public static WebCamera GetCamera2 => _graber2.WebCam;
        public static CoolingSetting GetCoolingSetting(this string value) =>
            _dataManager.Query<CoolingSetting>().FirstOrDefault(item => item.TypeName.Equals(value));

        /// <summary>
        /// 根据任务获取下一段路由步骤
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        private static int NextStepByTask(this EquipmentTask task)
        {
            var first = _routeSteps.FirstOrDefault(
                item => item.RouteOpKey.Equals(task.RouteType)
                        && item.RouteId.Equals(task.RouteId)
                        && item.RouteStepId.Equals(task.RouteStepId));
            if (first != null)
                return first.NextStep;
            throw new Exception();
        }

        /// <summary>
        /// 获取加热时间
        /// </summary>
        /// <param name="heatStep"></param>
        /// <returns></returns>
        public static HeatingSetting GetHeatingTime(this string heatStep) =>
            GetLiquidHeatings.FirstOrDefault(item => item.CurrentStep.Equals(heatStep));

        /// <summary>
        /// 获取加热总数
        /// </summary>
        /// <returns></returns>
        public static int GetHeatingTimeSum() => GetLiquidHeatings.Sum(item => item.HeatingTime);

        public static int MotorFinal(this string motorName)
        {
            var motor = GetMotor.FirstOrDefault(item => item.EquipmentName.Equals(motorName));
            return Math.Abs(Convert.ToInt32(Math.Round(motor.FinalPoint * motor.ConvertRatio)));
        }

        /// <summary>
        /// 获取移动距离
        /// </summary>
        /// <param name="location"></param>
        /// <param name="pointName"></param>
        /// <returns></returns>
        public static int CalculateAreaPoint(this string location, string pointName)
        {
            var motor = GetMotor.First(item => item.EquipmentName.Equals(pointName));
            var area = GetAreas.FirstOrDefault(item => item.PointName.Equals(location));
            if (motor is null) throw new ArgumentNullException(pointName);
            var value = 0.0;
            if (area is null)
                return 0;
            value = pointName switch
            {
                "MotorX" => area.LocationX - motor.FinalPoint,
                "MotorY" => area.LocationY - motor.FinalPoint,
                "MotorZ" => area.LocationZ,
                "MotorT" => area.LocationT - motor.FinalPoint,
                _ => throw new ArgumentNullException(pointName)
            };
            motor.FinalPoint += value;
            if (pointName== "MotorY")
            {
                return Convert.ToInt32(Math.Round(-value * motor.ConvertRatio));
            }
            var row = _dataManager.Update(motor);
            return Convert.ToInt32(Math.Round(-value * motor.ConvertRatio));
        }

        /// <summary>
        /// 获取设备对应状态
        /// </summary>
        /// <param name="equipmentName"></param>
        /// <returns></returns>
        public static EquipmentStatus GetEquipmentState(this string equipmentName) =>
            GetEquipmentStatuses.FirstOrDefault(item => item.EquipmentName.Equals(equipmentName));


        /// <summary>
        /// 获取路由步骤名称
        /// </summary>
        /// <param name="routeStepId"></param>
        /// <returns></returns>
        private static Step GetStepName(this int routeStepId) =>
            _steps.FirstOrDefault(step => step.RouteStepId.Equals(routeStepId));

        /// <summary>
        /// 组装下发任务数据参数
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static DataEventArgs GetDataArgs(this EquipmentTask task)
        {
            return new DataEventArgs
            {
                Proxy = _proxyContent,
                DataManager = _dataManager,
                Client = _optClient,
                LiquidDrop = _dropArgs,
                Task = task,
                Motor = GetMotor,
            };
        }

        /// <summary>
        /// 将点位状态置为可用
        /// </summary>
        /// <param name="fromPoint"></param>
        public static void UpdateAreaPointState(this string fromPoint)
        {
            var area = GetAreas.FirstOrDefault(item => item.PointName.Equals(fromPoint));
            if (area is null) return;
            area.Status = true;
            _dataManager.Update(area);
            logger.LogInformation($"将点位{fromPoint}置为可用");
        }

        /// <summary>
        /// 改变设备的最后地址
        /// </summary>
        /// <param name="equipmentName"></param>
        public static void UpdateMotorPoint(this string equipmentName)
        {
            var area = GetMotor.FirstOrDefault(item => item.EquipmentName.Equals(equipmentName));
            if (area is null) return;
            area.FinalPoint = 0;
            _dataManager.Update(area);
        }

        /// <summary>
        /// 获取设备区域的点位
        /// </summary>
        /// <param name="outArea"></param>
        /// <param name="routeId"></param>
        public static bool GetEquipmentAreaPoint(this int routeId, out string outArea, string opKey,string HighOrLow)
        {
            lock (obj_area_lock)
            {
                outArea = null;
                var route = _routes.FirstOrDefault(item => item.RouteId.Equals(routeId) && item.OpKey.Equals(opKey));
                if (route != null && route.From.Equals(route.To))
                    return true;
                if (route != null && route.To.In("SamplePosition", "LiquidWastePosition"))
                    return true;

                //EquipmentArea area;
                //if (route.To == "TitrationPosition" && HighOrLow == "High")
                //{
                //    area = GetAreas.Where(item => route != null && item.AreaName.Equals(route.To) && item.PointName.Equals("D1"))
                //      .FirstOrDefault(item => item.Status.Equals(true));
                //    if (area == null)
                //        return false;
                //    area = GetAreas.Where(item => route != null && item.AreaName.Equals(route.To) && item.PointName.Equals("D2"))
                //      .FirstOrDefault(item => item.Status.Equals(true));
                //    if (area == null)
                //        return false;
                //    area.Status = false;
                //    _dataManager.Update(area);
                //    outArea = "D2";
                //    return true;
                //}
                //else if (route.To == "TitrationPosition" && HighOrLow == "Low")
                //{
                //    area = GetAreas.Where(item => route != null && item.AreaName.Equals(route.To) && item.PointName.Equals("D2"))
                //     .FirstOrDefault(item => item.Status.Equals(true));
                //    if (area == null)
                //        return false;
                //    area = GetAreas.Where(item => route != null && item.AreaName.Equals(route.To) && item.PointName.Equals("D1"))
                //      .FirstOrDefault(item => item.Status.Equals(true));
                //    if (area == null)
                //        return false;
                //    area.Status = false;
                //    _dataManager.Update(area);
                //    outArea = "D1";
                //    return true;
                //}
                //else
                //{
                //    area = GetAreas.Where(item => route != null && item.AreaName.Equals(route.To))
                //       .FirstOrDefault(item => item.Status.Equals(true));
                //    if (area == null)
                //        return false;
                //    area.Status = false;
                //    _dataManager.Update(area);
                //    outArea = area.PointName;
                //    return true;
                //}
                #region
                var area = GetAreas.Where(item => route != null && item.AreaName.Equals(route.To))
                   .FirstOrDefault(item => item.Status.Equals(true));
                if (area == null)
                    return false;
                area.Status = false;
                _dataManager.Update(area);
                outArea = area.PointName;
                return true;
                #endregion 
            }
        }

        #region 路由更新

        /// <summary>
        /// 更新路由（集中更新）
        /// </summary>
        /// <param name="task"></param>
        public static void UpdateStepToTask(this EquipmentTask task)
        {
            try
            {

                var tasks = _dataManager.GetIsHaveEquipment(task);
                //做全部更新 更新到下一段路由
                //if (task.TaskType== "Clear_Out")
                //{
                //    task.RouteId = 12;
                //    task.RouteStepId = 1;
                //    tasks = _dataManager.GetIsHaveEquipment(task);
                //}
                var firstTask = tasks?.FirstOrDefault();
                if (firstTask is null) return;
                var nextstep = firstTask.NextStepByTask();
                //当stepId相等时，检查路由ID
                if (firstTask.RouteStepId.Equals(nextstep))
                {
                    var nextRoute = GetRoutes.FirstOrDefault(item =>
                        item.OpKey.Equals(firstTask.RouteType) && item.RouteId.Equals(firstTask.RouteId));
                   
                    if (nextRoute is not null)
                    {
                        //查看路由Id是否相等,相等则置为完成
                        if (nextRoute.NextRoute.Equals(nextRoute.RouteId))
                        {
                            tasks.ForEach(item => { item.Status = TaskState.Finished; });
                            _dataManager.Update(tasks);
                            return;
                        }

                        var nextRouteInitStep = GetRoutes.FirstOrDefault(item =>
                            item.RouteId.Equals(nextRoute.NextRoute) && item.OpKey.Equals(firstTask.RouteType));
                        if (nextRouteInitStep is null) return;
                        var nextRouteInitStepName = nextRouteInitStep.InitStep.GetStepName();
                        tasks.ForEach(item =>
                        {
                            if (nextRouteInitStep.From != nextRouteInitStep.To)
                            {
                                if (nextRouteInitStep.To.In("LiquidWastePosition", "SamplePosition"))
                                {
                                    item.From = item.To;
                                    item.To = item.OriginLocalName;
                                }

                                if (nextRouteInitStep.From.In("LiquidWastePosition", "SamplePosition"))
                                {
                                    item.From = item.OriginLocalName;
                                }
                            }

                            if (nextRouteInitStep.From.Equals(nextRouteInitStep.To))
                                item.From = item.To;
                            item.Status = TaskState.New;
                            item.RouteId = nextRoute.NextRoute;
                            item.RouteStepId = nextRouteInitStep.InitStep;
                            item.RouteStep = nextRouteInitStepName?.RouteStepName;
                            item.RouteUpdateType = nextRouteInitStepName?.UpdateRange;
                        });
                        var initStep1 = nextstep.GetStepName();
                        if (initStep1.RouteStepName== "Clear_Cooling")
                        {
                            var routeStepBB = GetRouteSteps.FirstOrDefault(item => item.RouteStepId.Equals(29) && item.RouteOpKey.Equals(task.RouteType));
                            var nextStepBB = GetSteps.FirstOrDefault(item => item.RouteStepId.Equals(routeStepBB.RouteStepId));
                            tasks.ForEach(item =>
                            {
                                if (item.TaskType == "补杯")
                                {
                                    item.Status = TaskState.New;
                                    item.RouteStepId = routeStepBB.RouteStepId;
                                    item.RouteStep = nextStepBB?.RouteStepName;
                                    item.RouteUpdateType = nextStepBB?.UpdateRange;
                                    item.RouteId = 6;
                                }
                            });
                        }
                       
                        _dataManager.Update(tasks);
                        return;
                    }
                }

                var initStep = nextstep.GetStepName();
                
                tasks.ForEach(item =>
                {
                    item.Status = TaskState.New;
                    item.RouteStepId = nextstep;
                    item.RouteStep = initStep?.RouteStepName;
                    item.RouteUpdateType = initStep?.UpdateRange;
                });

                if (initStep.RouteStepName == "CA_Down")
                {
                    var routeStepBB = GetRouteSteps.FirstOrDefault(item => item.RouteStepId.Equals(10) && item.RouteOpKey.Equals(task.RouteType));
                    var nextStep = GetSteps.FirstOrDefault(item => item.RouteStepId.Equals(routeStepBB.RouteStepId));

                    tasks.ForEach(item =>
                    {
                        if (item.TaskType == "补杯")
                        {
                            item.Status = TaskState.New;
                            item.RouteStepId = routeStepBB.RouteStepId;
                            item.RouteStep = nextStep?.RouteStepName;
                            item.RouteUpdateType = nextStep?.UpdateRange;
                            item.RouteId = 4;
                        }
                    });
                }
                
                _dataManager.Update(tasks);
               
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        /// <summary>
        /// 路由更新（单步更新）
        /// </summary>
        /// <param name="task"></param>
        public static void UpdateRouteStep(this EquipmentTask task)
        {
            try
            {
                var routeStep = GetRouteSteps.FirstOrDefault(item =>
                    item.RouteId.Equals(task.RouteId) && item.RouteStepId.Equals(task.RouteStepId) &&
                    item.RouteOpKey.Equals(task.RouteType));
                if (routeStep is null) return;

                if (task.TaskType == "补杯" && task.RouteId == 1 && task.RouteStepId == 1)
                {
                    var routeStepBB = GetRouteSteps.FirstOrDefault(item => item.RouteStepId.Equals(1) && item.RouteOpKey.Equals(task.RouteType));
                    var nextStep = GetSteps.FirstOrDefault(item => item.RouteStepId.Equals(routeStepBB.RouteStepId));

                    task.RouteStepId = routeStepBB.RouteStepId;
                    task.RouteStep = nextStep?.RouteStepName;
                    task.RouteUpdateType = nextStep?.UpdateRange;
                    task.Status = TaskState.New;
                    task.RouteId = 2;

                    _dataManager.Update(task);
                    return;
                }
                if (task.TaskType == "补杯" && task.RouteId == 7 && task.RouteStepId == 1)
                {
                    task.To = task.OriginLocalName;
                }
                //如果是RouteStepID与NextStep相等，则查找下一段路由
                if (routeStep.RouteStepId.Equals(routeStep.NextStep) || task.TaskType == "补杯" && task.RouteId == 7 && task.RouteStepId == 8)
                {
                    //查找路由
                    var route = GetRoutes.FirstOrDefault(item =>item.RouteId.Equals(routeStep.RouteId) && item.OpKey.Equals(task.RouteType));
                    //如果下一段路由的RouteID与NextRoute相等，则代表没有后续步骤，完成任务
                    if (route is not null && route.RouteId.Equals(route.NextRoute) || task.TaskType == "补杯" && task.RouteId == 7 && task.RouteStepId == 8)
                    {
                       
                        if (task.TaskType == "补杯" && task.RouteId == 7 && task.RouteStepId == 8)
                        {
                            _dataManager.Delete(task);
                        }
                        else
                        {
                            task.Status = TaskState.Finished;
                            _dataManager.Update(task);
                        }
                    }
                    else
                    {
                        var initRoute = GetRoutes.FirstOrDefault(
                            item => route is not null && item.OpKey.Equals(task.RouteType) &&
                                    item.RouteId.Equals(route.NextRoute));

                        if (initRoute is not null && initRoute.From != initRoute.To)
                        {
                            if (initRoute.To.In("LiquidWastePosition", "SamplePosition"))
                            {
                                task.From = task.To;
                                task.To = task.OriginLocalName;
                            }
                            if (initRoute.To.In( "TitrationPosition2"))
                            {
                                task.From = task.To;
                            }

                            if (initRoute.From.In("LiquidWastePosition", "SamplePosition"))
                            {
                                task.From = task.OriginLocalName;
                            }
                        }
                        
                        if (initRoute is not null && initRoute.From.Equals(initRoute.To))
                            task.From = task.To;
                        
                        task.Status = TaskState.New;
                        if (initRoute is not null)
                        {
                            var initStep = GetSteps.FirstOrDefault(item => item.RouteStepId.Equals(initRoute.InitStep));
                            task.RouteId = initRoute.RouteId;
                            task.RouteStepId = initRoute.InitStep;
                            task.RouteStep = initStep?.RouteStepName;
                            task.RouteUpdateType = initStep?.UpdateRange;
                        }
                       
                        _dataManager.Update(task);
                    }
                }
                else
                {
                   
                    var nextStep = GetSteps.FirstOrDefault(item => item.RouteStepId.Equals(routeStep.NextStep));
                    task.RouteStepId = routeStep.NextStep;
                    task.RouteStep = nextStep?.RouteStepName;
                    task.RouteUpdateType = nextStep?.UpdateRange;

                    _dataManager.Update(task);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                throw;
            }
        }
        #endregion
    }
}