SHJX_cod/SHJX.Service.Control/ServiceController/MainController.cs

using System;
using System.Linq;
using System.Text;
using SHJX.Service.Dao;
using SHJX.Service.Model.Dao;
using System.Threading.Tasks;
using System.Collections.Generic;
using SHJX.Service.Common.Extend;
using SHJX.Service.Model.Control;
using SHJX.Service.Common.ReadXML;
using SHJX.Service.Common.ExtendElement;
using SHJX.Service.CustomControl;
using System.Data;
using Newtonsoft.Json.Linq;
using System.Xml.Linq;

namespace SHJX.Service.Control.ServiceController
{
    public class MainController
    {
        /// <summary>
        /// 配置文件
        /// </summary>
        private static ReadConfigUtil _config;
        /// <summary>
        /// 数据库
        /// </summary>
        private static MainManager _dataManager;
        public   MainManager DataManager;

        public MainController(ReadConfigUtil config)
        {
            _config = config;
            _dataManager = new MainManager(config);
            DataManager = _dataManager;
        }

        public List<EquipmentMotor> GetEquipmentMotors()
        {
            return DataCentre.GetMotor;
        }

        /// <summary>
        /// 打开连接
        /// </summary>
        public Task<(string, bool)> ClientOpen()
        {
            return Task.Factory.StartNew(() => DataCentre.GetClient.Open());
        }

        /// <summary>
        /// 设置速度、加速度、减速度
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool SetSpeed(MotorSpeed speed)
        {
            #region 速度
            PortArgs speedArgs = new PortArgs()
            {
                TypeName = speed.NodeName,
                Distance = speed.Speed,
                WriteWay = WriteWay.Speed
            };
            var res = DataCentre.GetClient.Factory(speed.NodeName).Write(speedArgs);
            #endregion

            #region 加速度

            var acSpeedArgs = new PortArgs()
            {
                TypeName = speed.NodeName,
                Distance = speed.AcSpeed,
                WriteWay = WriteWay.AcSpeed
            };
            res = res && DataCentre.GetClient.Factory(speed.NodeName).Write(acSpeedArgs);

            #endregion

            #region 减速度

            PortArgs deSpeedArgs = new()
            {
                TypeName = speed.NodeName,
                Distance = speed.DeSpeed,
                WriteWay = WriteWay.DeSpeed
            };
            res = res && DataCentre.GetClient.Factory(speed.NodeName).Write(deSpeedArgs);

            #endregion

            return res;
        }

        public List<(string, string)> GetHeatAtPresent()
        {
            List<(string, string)> ringNames = new List<(string, string)>();
            foreach (var item in _dataManager.GetHeatingTaskAtPresent())
            {
                ringNames.Add((item.To, item.OriginLocalName.Replace("A", string.Empty)));
            }
            return ringNames;
        }

        public bool CheckHeatingIsRunning()
        {
            var equipment = _dataManager.CheckHeatRodStatus();
            EquipmentEnum[] status = new EquipmentEnum[] { EquipmentEnum.Start, EquipmentEnum.Waiting };
            return status.Contains(equipment.EquipmentState);
        }

        public bool UpdateHeatingIsRunning()
        {
            var portArgs = new PortArgs
            {
                TypeName = "Heat",
                Distance = -100,
            Reserve = DataCentre._dataManager.GetPid("Dissolve")
            };
            DataCentre.GetClient.Factory("Heat").Write(portArgs);
            var equipment = _dataManager.CheckHeatRodStatus();
            equipment.EquipmentState = EquipmentEnum.Stop;
            equipment.Udf1 = string.Empty;
            equipment.Udf2 = "0";
            return _dataManager.Update(equipment) > 0;
        }


        /// <summary>
        /// 启动时，所有设备返回原点
        /// </summary>
        /// <returns></returns>
        public async Task<bool> StartEquipmentGoBackAsync()
        {
            #region 四轴
            var portArgs = new PortArgs()
            {
                ReadWay = "OriginalPosition",
                WriteWay = WriteWay.GoBack
            };

            #region Z轴单独罗列
            portArgs.TypeName = "MotorZ";
            if (!((bool)DataCentre.GetClient.Factory("MotorZ").Read(portArgs)))
            {
                DataCentre.GetClient.Factory("MotorZ").Write(portArgs);
            }
            portArgs.TypeName.UpdateMotorPoint();
            #endregion

            #region X、Y、T轴
            #region 设置电机速度
            if (_config.SpeedWrite)
            {
                MotorSpeed item = _config.GetSpeed[0];
                item.Speed = 6;
                SetSpeed(item);

                MotorSpeed item1 = _config.GetSpeed[1];
                item1.Speed = 6;
                SetSpeed(item1);
            }
            #endregion
            string[] gobackPoint = new string[] { "MotorX", "MotorY", "MotorT" };
            var res = true;
            foreach (var item in gobackPoint)
            {
                res = res && await Task.Factory.StartNew(() =>
                {
                    portArgs.TypeName = item;
                    return (bool)DataCentre.GetClient.Factory(item).Read(portArgs) || DataCentre.GetClient.Factory(item).Write(portArgs);
                });
                item.UpdateMotorPoint();
            }
            #region 设置电机速度
            if (_config.SpeedWrite)
            {
                MotorSpeed item = _config.GetSpeed[0];
                SetSpeed(item);

                MotorSpeed item1 = _config.GetSpeed[1];
                SetSpeed(item1);
            }
            #endregion
            #endregion

            #endregion

            #region 升降台

            var cagePortArgs = new PortArgs()
            {
                TypeName = "Cage",
                WriteWay = WriteWay.Normotopia
            };
            res = res && DataCentre.GetClient.Factory("Cage").Write(cagePortArgs);
            var cageStatus = _dataManager.GetEquipmentStatusByName("Cage");
            cageStatus.EquipmentState = EquipmentEnum.Normotopia;
            _dataManager.Update(cageStatus);
            #endregion

            #region 消解位
            var dissolvePortArgs = new PortArgs()
            {
                TypeName = "Dissolve",
                ReadWay = "OriginalPosition",
                WriteWay = WriteWay.Antiposition
            };
            res = res && (bool)DataCentre.GetClient.Factory("Dissolve").Read(dissolvePortArgs) || DataCentre.GetClient.Factory("Dissolve").Write(dissolvePortArgs);
            "Dissolve".UpdateMotorPoint();
            var dissolveStatus = _dataManager.GetEquipmentStatusByName("DissolvePosition");
            dissolveStatus.EquipmentState = EquipmentEnum.Normotopia;
            _dataManager.Update(dissolveStatus);
            #endregion

            res = DataCentre.GetStorageContent.Factory("DripNozzle").Stop();

            #region 硫酸银泵回原点
            var silverSulfatePortArgs = new PortArgs()
            {
                TypeName = "SilverSulfate",
                ReadWay = "OriginalPosition",
                WriteWay = WriteWay.GoBack
            };
            int count = 20;
            while (!((bool)DataCentre.GetClient.Factory("SilverSulfate").Read(silverSulfatePortArgs)))
            {
                if (count-- < 1)
                { break; }
                silverSulfatePortArgs.WriteWay = WriteWay.Move;
                silverSulfatePortArgs.Distance = 1000;
                DataCentre.GetClient.Factory("SilverSulfate").Write(silverSulfatePortArgs);
            }
            #endregion
            //res = DataCentre.GetStorageContent.Factory("DripNozzle2").Stop();

            return res;
        }
        public bool zBackToPoint()
        {
            PortArgs portArg = new()
            {
                WriteWay = WriteWay.GoBack,
                TypeName = "MotorZ",
                Distance = "MotorZ".MotorFinal()
            };
            var res = DataCentre.GetClient.Factory("MotorZ").Write(portArg);
            return res;

        }

        public List<EquipmentTask> GetResidueWashTasks()
        {
            return _dataManager.GetResidueWashTask();
        }

        /// <summary>
        /// 获取剩余任务
        /// </summary>
        /// <returns></returns>
        public List<EquipmentTask> GetResidueTask()
        {
            return _dataManager.GetEquipmentTasks();
        }

        /// <summary>
        /// 根据uuid获取任务
        /// </summary>
        /// <param name="guid"></param>
        /// <param name="states"></param>
        /// <returns></returns>
        public List<EquipmentTask> GetTaskByUUID(string guid, params TaskState[] states)
        {
            return _dataManager.QueryTaskByUuid(guid, states).ToList();
        }

        /// <summary>
        /// 删除剩余任务
        /// </summary>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public bool DeleteResidueTask(List<EquipmentTask> tasks)
        {
            var rows = _dataManager.Delete(tasks);
            return rows > 0;
        }

        /// <summary>
        /// 更新剩余任务状态（变更为取消）
        /// </summary>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public bool UpdateResidueTaskState(List<EquipmentTask> tasks)
        {
            var rows = _dataManager.Update(tasks);
            return rows > 0;
        }
        public bool UpdateTaskState(EquipmentTask task)
        {
            var task2= _dataManager.GetEquipmentTasks(task).Where(item => item.OriginLocalName.Equals(task.OriginLocalName)).ToList();
            if(task2.Count > 0)
                {
                task2[0].Result = task.Result;
                task2[0].Amount = task.Amount;
                var rows = _dataManager.Update(task2); 
                return rows == 1;
            }
            else
                return false;
        }

        /// <summary>
        /// 查询区域
        /// </summary>
        /// <returns></returns>
        public List<EquipmentArea> QueryArea()
        {
            return _dataManager.GetAreasByDisable();
        }

        public string GetWavekeyValue()
        {
            OptionWindows option = new(_dataManager.GetWavekeys());
            return (bool)option.ShowDialog() ? option.WaveKey : string.Empty;
        }

        /// <summary>
        /// Word转换
        /// </summary>
        /// <param name="wavekey"></param>
        /// <returns></returns>
        public async Task<bool> ConvertWordAsync(string wavekey)
        {
            try
            {
                var path = _config.ResultWordFilePath;
                var maxVolume = DataCentre.GetBalanceValue.MaxVolume;
                var tasks = _dataManager.QueryTaskByUuid(wavekey, TaskState.Finished);
                if (!tasks.Any())
                {
                    UMessageBox.Error("暂未发现已完成任务!");
                    return false;
                }

                if (string.IsNullOrWhiteSpace(path))
                {
                    UMessageBox.Error("请查看保存路径是否正确!");
                    return false;
                }
                var res = false;
                if (_config.ExportTypeByWord) 
                {
                   res = await Task.Factory.StartNew(() => tasks.ConvertToWord(path, maxVolume));
                }
                else if(_config.ExportTypeByExcel)
                { res = await Task.Factory.StartNew(() => tasks.ConvertToExcel(path)); }
                return res;
            }
            catch (Exception)
            {
                throw new Exception();
            }
        }
        public void deleteTask(string nodeName)
        {
            _dataManager.QuerydeledeTask(nodeName);
        }
        public void QuerydeledeEmptyCupTask(string nodeName)
        {
            _dataManager.QuerydeledeEmptyCupTask(nodeName);
        }
        /// <summary>
        /// UI界面任务下发水样任务
        /// </summary>
        /// <param name="args"></param>
        /// <param name="waveKey"></param>
        /// <returns></returns>
        public IEnumerable<ResponseData> SendSampleToControl(List<SampleDetail> args, string waveKey)
        {
            var tasks = new List<EquipmentTask>();
            var resList = new List<ResponseData>();
            var successSend = new StringBuilder(); //这里是已下发的
            var repetitionSend = new StringBuilder(); //这里是重复
            foreach (var item in args)
            {
                if (_dataManager.QueryContainTask(item.NodeName))
                {
                    repetitionSend.AppendFormat("{0} ", item.NodeName);
                    continue;
                }
                successSend.AppendFormat("{0} ", item.NodeName);
                var task = item.NewSampleTask(waveKey); //创建任务
                tasks.Add(task);
                _dataManager.QuerydeledeTask(item.NodeName);
            }
            
            _dataManager.Insert(tasks);
            var successData = new ResponseData();
            var errorData = new ResponseData();
            if (successSend.Length > 0)
            {
                successData.Code = 200;
                successData.Message = string.Concat(successSend.ToString(), "任务下发成功！");
                resList.Add(successData);
                return resList;
            }

            if (repetitionSend.Length <= 0) return resList;
            errorData.Code = 404;
            errorData.Message = string.Concat(repetitionSend.ToString(), "地址有在执行的任务，请勿重复下发任务！");
            resList.Add(errorData);

            return resList;
        }

        /// <summary>
        /// 检查是否已存在任务
        /// </summary>
        /// <returns></returns>
        public bool CheckExistTask()
        {
            return _dataManager.GetEquipmentTasks().Where(item => item.Status.Equals(TaskState.New) || item.Status.Equals(TaskState.Doing)).Any();
        }

        public List<EquipmentTask> CheckExistTaskBD(string wavekey)
        {
            return _dataManager.GetEquipmentTasksBD(wavekey).Where(item => item.Status.Equals(TaskState.Finished)).ToList();
        }

        public List<EquipmentTask> GetUpdateValue(params string[] values)
        {
            return _dataManager.GetTaskByConcentration(values);
        }

        /// <summary>
        /// 下发润洗的任务
        /// </summary>
        public bool SendWashTask(string detailName,string waveKey)
        {
            if (_dataManager.GetResidueWashTask().Any())
                return false;
            var washTask = detailName.NewWashTask();
            washTask.WaveKey = waveKey;
            if (washTask is null) return false;
            return _dataManager.Insert(washTask) > 0;
        }

        /// <summary>
        /// 写入预热温度
        /// </summary>
        public void WritePreheatTemperature()
        {
            var portArgs = new PortArgs
            {
                TypeName = "Heat",
                Reserve = _dataManager.GetPid("Preheat"),
                Distance = Convert.ToInt32(_config.PreheatTemperature)
            };
            DataCentre.GetClient.Factory("Heat").Write(portArgs);
            Action action = () => UMessageBox.SuccessTip("预热写入成功！");
            do
            {
                if (DataCentre.GetClient.Factory("Heat").Read(portArgs) is not Dictionary<string, double> obj) continue;
                //设定温度小于或等于实际温度
                if (Math.Round(obj["sv"]) <= Math.Round(obj["pv"])) break;
            } while (true);
            portArgs.Distance = -100;
            DataCentre.GetClient.Factory("Heat").Write(portArgs);
            action = () => UMessageBox.SuccessTip("预热结束！");
        }

        public void StopHeatingTemperature()
        {
            if (CheckHeatingIsRunning())
            {
                var portArgs = new PortArgs
                {
                    TypeName = "Heat",
                    Distance = -99,
                    Reserve = DataCentre._dataManager.GetPid("Dissolve")
                };
                DataCentre.GetClient.Factory("Heat").Write(portArgs);
                string EquipmentName = "HeatRod";
                var status = EquipmentName.GetEquipmentState(); //获取加热棒的状态
                status.EquipmentState = EquipmentEnum.Waiting;
                _dataManager.Update(status);
                Action action = () => UMessageBox.SuccessTip("已停止加热！");
            }
            
        }

        /// <summary>
        /// 获取WaveKey
        /// </summary>
        /// <returns></returns>
        public string GetWavekey()
        {
            List<EquipmentTask> equipmentTasks = _dataManager.GetExistTask();
            if (equipmentTasks.Any())
            {
                return equipmentTasks.GroupBy(item => item.WaveKey).FirstOrDefault()?.Key;
            }
            Batch batch = _dataManager.GetBatch();
            if (batch == null || batch.Createtime.ToString("yyyyMMdd") != DateTime.Now.ToString("yyyyMMdd"))
            {
                batch = new Batch
                {
                    CurrentValue = 1,
                    Createtime = DateTime.Now
                };
            }
            else
            {
                ++batch.CurrentValue;
            }
            _dataManager.Insert(batch);
            Wavekey wavakey = new()
            {
                WaveKey = $"{DateTime.Now:yyyyMMdd}{batch.CurrentValue.ToString().PadLeft(3, '0')}"
            };
            //20210604001;
            _dataManager.Insert(wavakey);
            return wavakey.WaveKey;
        }

       
    }
}