MES / DataAcquisition · Files

using System.Collections.ObjectModel;
using System.Configuration;
using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using FreeSql;
using HHECS.DAQClient.Common;
using HHECS.DAQClient.Common.Enums;
using HHECS.DAQClient.DataAccess;
using HHECS.DAQClient.Model;
using HHECS.DAQClient.Services;
using HHECS.DAQClient.View;
using HHECS.DAQClient.View.CommunicationView;
using HHECS.DAQClient.View.EquipmentView;
using HHECS.EquipmentModel;
using MessageBox = HandyControl.Controls.MessageBox;

namespace HHECS.DAQClient.ViewModel
{
    internal partial class MainVM : ObservableObject
    {
        [ObservableProperty]
        private bool btnStartEnabled = true;

        [ObservableProperty]
        private bool btnStopEnabled = false;

        [ObservableProperty]
        private ObservableCollection<LogModel> logModels = new();

        [ObservableProperty]
        private Page communicationPage = new CommunicationPage();

        [ObservableProperty]
        private Page equipmentPage = new EquipmentPage();

        [ObservableProperty]
        private Page equipmentDataQueuePage = new EquipmentDataQueuePage();

        /// <summary>
        /// 自动上传数据
        /// </summary>
        [ObservableProperty]
        private bool autoCommit = true;

        /// <summary>
        /// 每次提交的数据量
        /// </summary>
        private int _commitCount = 30;
        private readonly SystemLog _log = SystemLog.GetInstance();
        private readonly CenterService _centerService;
        private readonly HttpService _httpService;
        private readonly DataContext _context;
        public MainVM(DataContext context, CenterService centerService, HttpService httpService)
        {
            _centerService = centerService;
            _httpService = httpService;
            _context = context;
            Initial();
        }

        private void Initial()
        {
            //GenerateData();
            var commitCountConfig = ConfigurationManager.AppSettings["CommitCount"];
            _ = bool.TryParse(ConfigurationManager.AppSettings["AutoExecute"], out var autoExecute);
            _ = int.TryParse(commitCountConfig, out _commitCount);
            if (_commitCount <= 0)
            {
                //未配置，则默认100
                _commitCount = 100;
            }
            RefreshLog();
            UploadEquipmentDataToCloud();
            UpdataClientStatus();
            if (autoExecute)
            {
                Start();
            }
        }

        /// <summary>
        /// 上传数据至IOTClound
        /// </summary>
        private void UploadEquipmentDataToCloud()
        {
            Task.Run(async () =>
            {
                var index = 0;
                while (true)
                {
                    try
                    {
                        await Task.Delay(1000);
                        if (!_centerService.EquipmentDataQueues.IsEmpty)
                        {
                            var temps = new List<EquipmentDataQueue>();
                            var commitFailureRecords = new List<EquipmentDataQueue>();
                            for (int i = 0; i < _commitCount; i++)
                            {
                                var result = _centerService.EquipmentDataQueues.TryDequeue(out var item);
                                if (!result) break;
                                if (item != null)
                                {
                                    temps.Add(item);
                                }
                            }

                            //自动上传启用，且数据库无未上传的数据，则直接推送
                            if (AutoCommit && !_context.EquipmentDataQueue.Where(x => true).Any())
                            {
                                var tasks = new List<Task<List<EquipmentDataQueue>>>();
                                foreach (var item in temps.GroupBy(x => x.EquipmentCode))
                                {
                                    tasks.Add(Task.Run(() =>
                                    {
                                        Stopwatch stopwatch = Stopwatch.StartNew();
                                        var records = item.OrderBy(x => x.SourceTimestamp).ToList();
                                        var result = _httpService.SendEquipmentData(records);
                                        if (!result.Success)
                                        {
                                            _log.LogError($"推送设备[{item.Key}]数据失败，{result.Msg}，耗时：{stopwatch.ElapsedMilliseconds}ms");
                                            return records;
                                        }
                                        _log.LogSuccess($"成功推送{records.Count}条设备[{item.Key}]数据，耗时：{stopwatch.ElapsedMilliseconds}ms");
                                        return new List<EquipmentDataQueue>();
                                    }));
                                }
                                Task.WaitAll(tasks.ToArray());
                                commitFailureRecords = tasks.SelectMany(x => x.Result).ToList();
                            }
                            //自动上传关闭或数据库存在未上传的记录，则直接存入数据库
                            else
                            {
                                commitFailureRecords.AddRange(temps);
                            }

                            //将上传失败的数据存入数据库
                            if (commitFailureRecords.Count > 0)
                            {
                                _context.EquipmentDataQueue.AddRange(commitFailureRecords);
                                _context.SaveChanges();
                                _log.LogInfo($"新增{commitFailureRecords.Count}条数据记录");
                            }
                        }

                        if (BtnStartEnabled)
                        {
                            //未启动，1s/次
                            index = 0;
                        }
                        else
                        {
                            //启动时，5s/次
                            index++;
                        }

                        if (AutoCommit && index % 5 == 0)
                        {
                            if (!_context.EquipmentDataQueue.Where(x => true).Any())
                            {
                                continue;
                            }
                            var equipmentCodes = _context.EquipmentDataQueue.Where(x => true).Distinct().ToList(x => x.EquipmentCode);
                            //推送成功的数据集合
                            var tasks = new List<Task<List<EquipmentDataQueue>>>();
                            foreach (var equipmentCode in equipmentCodes)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    Stopwatch stopwatch = Stopwatch.StartNew();
                                    var temps = _context.EquipmentDataQueue.Where(x => x.EquipmentCode == equipmentCode && !x.IsCommit).OrderBy(x => x.SourceTimestamp).Take(_commitCount).ToList();
                                    if (temps.Count == 0)
                                    {
                                        return new List<EquipmentDataQueue>();
                                    }
                                    var result = _httpService.SendEquipmentData(temps);
                                    if (!result.Success)
                                    {
                                        _log.LogError($"推送设备[{equipmentCode}]数据失败，{result.Msg}，耗时：{stopwatch.ElapsedMilliseconds}ms");
                                        return new List<EquipmentDataQueue>();
                                    }
                                    _log.LogSuccess($"成功推送{temps.Count}条设备[{equipmentCode}]数据，耗时：{stopwatch.ElapsedMilliseconds}ms");
                                    return temps;
                                }));
                            }
                            Task.WaitAll(tasks.ToArray());
                            var commitSuccessRecords = tasks.SelectMany(x => x.Result).ToList();
                            if (commitSuccessRecords.Count > 0)
                            {
                                _context.EquipmentDataQueue.RemoveRange(commitSuccessRecords);
                                _context.SaveChanges();
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.LogException($"数据上传线程异常：{ex.Message}");
                    }
                }
            });
        }

        private void UpdataClientStatus()
        {
            Task.Run(async () =>
            {
                while (true)
                {
                    await Task.Delay(5000);
                    if (BtnStartEnabled)
                    {
                        continue;
                    }
                    _ = Guid.TryParse(ConfigurationManager.AppSettings["ClientId"], out var clientId);
                    var result = _httpService.UpdateClientStatus(clientId);
                    if (!result.Success)
                    {
                        _log.LogError($"更新客户端状态失败：{result.Msg}");
                    }
                }
            });
        }

        [RelayCommand]
        public void Start()
        {
            _ = bool.TryParse(ConfigurationManager.AppSettings["PrivacyInfoStatus"], out var privacyInfoStatus);
            if (!privacyInfoStatus)
            {
                var vm = new PrivacyInfoView();
                var result = vm.ShowDialog();
                if (result != true)
                {
                    return;
                }
            }

            BtnStartEnabled = false;
            BtnStopEnabled = true;
            _centerService.Start();
        }

        [RelayCommand]
        public void Stop()
        {
            BtnStartEnabled = true;
            BtnStopEnabled = false;
            _centerService.Stop();
        }

        private void RefreshLog()
        {
            Task.Run(() =>
            {
                Application.Current.Dispatcher.Invoke(async () =>
                {
                    do
                    {
                        while (!_log.IsEmpty)
                        {
                            var log = _log.GetLog();
                            if (log == null)
                            {
                                await Task.Delay(100);
                                continue;
                            }

                            var oldItem = LogModels.Where(x => x.Messages.Equals(log.Messages)).FirstOrDefault();
                            if (oldItem != null)
                            {
                                oldItem.CreateTime = log.CreateTime;
                                LogModels = new ObservableCollection<LogModel>(LogModels.OrderByDescending(x => x.CreateTime));
                            }
                            else
                            {
                                LogModels.Insert(0, new LogModel()
                                {
                                    LogType = log.LogType,
                                    Messages = log.Messages,
                                    CreateTime = log.CreateTime
                                });
                            }
                            if (LogModels.Count > 50)
                            {
                                LogModels.Remove(LogModels.Last());
                            }
                        }
                        await Task.Delay(100);
                    } while (true);
                });
            });
        }

        /// <summary>
        /// 生成数据
        /// </summary>
        private void GenerateData()
        {
            var stationCodeArea1 = new List<string>
            {
                "P1001",
                "P1002",
                "P1004",
                "P1005",
                "P1007",
                "P1008",
                "P1009",
                "P1010",
                "P1011",
                "P1012",
                "P1013",
                "P1014",
                "P1015",
                "P1016",
                "P1017",
                "P1018",
            };

            var stationCodeArea2 = new List<string>
            {
                "P1001",
                "P1002",
                "P1004",
                "P1006",
                "P1007",
            };

            var stationCodeArea3 = new List<string>
            {
                "P1001",
                "P1002",
                "P1003",
                "P1004",
                "P1005",
                "P1006",
                "P1007",
                "P1008",
                "P1009",
                "P1010",
                "P1011",
                "P1012",
                "P1013",
                "P1014",
                "P1015",
                "P10161",
                "P10162",
            };

            //GenerateStationMonitorEquipment(stationCodeArea1, "192.168.10.103", "1");
            //GenerateStationMonitorEquipment(stationCodeArea2, "192.168.10.10", "2");
            //GenerateStationMonitorEquipment(stationCodeArea3, "192.168.10.50", "3");
        }

        /// <summary>
        /// 生成站台监控数据
        /// </summary>
        /// <param name="stationCode"></param>
        /// <param name="ip"></param>
        /// <param name="destinationArea"></param>
        private void GenerateStationMonitorEquipment(IEnumerable<string> stationCode, string ip, string destinationArea)
        {
            try
            {
                var equipmentType = _context.EquipmentType.Where(x => x.Code == EquipmentTypeConst.StationMonitor.ToString()).First();
                var equipmentPropTemps = _context.EquipmentTypePropTemplate.Where(x => x.EquipmentTypeId == equipmentType.Id).ToList();

                var equipmentTemps = new List<Equipment>();
                foreach (var station in stationCode)
                {
                    var equipment = new Equipment
                    {
                        Code = station,
                        Name = $"{station}站台监控",
                        EquipmentTypeId = equipmentType.Id,
                        IP = ip,
                        Created = DateTime.Now,
                        DestinationArea = destinationArea,
                        Description = station,
                        ConnectName = station
                    };
                    equipmentTemps.Add(equipment);
                }
                _context.Equipment.AddRange(equipmentTemps);
                _context.SaveChanges();

                var dbStart1 = 0;
                var dbStart2 = 0;
                var equipmentProps = new List<EquipmentProp>();
                foreach (var equipment in equipmentTemps)
                {
                    var equipmentId = _context.Equipment.Where(x => x.ConnectName == equipment.ConnectName && x.IP == x.IP && x.DestinationArea == destinationArea).First(x => x.Id);

                    foreach (var item in equipmentPropTemps)
                    {
                        _ = Enum.TryParse<StationMonitorProp>(item.Code, out var StationMonitorCode);
                        var address = StationMonitorCode switch
                        {
                            StationMonitorProp.StationMonitorBarcode => $"DB3002.{dbStart1},20",
                            StationMonitorProp.StationMonitorAutomation => $"DB3002.{dbStart1 + 20}",
                            StationMonitorProp.StationMonitorOccupied => $"DB3002.{dbStart1 + 22}",
                            StationMonitorProp.StationError => $"DB3002.{dbStart1 + 24}",
                            StationMonitorProp.StationDestination => $"DB3002.{dbStart1 + 26}",
                            StationMonitorProp.StationBackup => $"DB3002.{dbStart1 + 28}",
                            StationMonitorProp.StationCorotation => $"DB3200.{dbStart2 / 8}.{dbStart2 % 8}",
                            StationMonitorProp.StationReverse => $"DB3200.{(dbStart2 + 1) / 8}.{(dbStart2 + 1) % 8}",
                            StationMonitorProp.StationHighSpeed => $"DB3200.{(dbStart2 + 2) / 8}.{(dbStart2 + 2) % 8}",
                            _ => string.Empty,
                        };
                        var prop = new EquipmentProp
                        {
                            EquipmentId = equipmentId,
                            EquipmentTypePropTemplateId = item.Id,
                            EquipmentTypePropTemplateCode = item.Code,
                            Address = address,
                            Remark = item.Name,
                            ServerHandle = 0,
                            Created = DateTime.Now,
                        };
                        equipmentProps.Add(prop);
                    }
                    dbStart1 += 30;
                    dbStart2 += 3;
                }
                _context.EquipmentProp.AddRange(equipmentProps);
                _context.SaveChanges();
            }
            catch (Exception ex)
            {
                _log.LogError(ex.Message);
            }
        }

        /// <summary>
        /// 将本地设备数据同步至IOT云平台
        /// </summary>
        private void SyncEquipmentDataToIotCloud()
        {
            var connectionString = "";//云平台数据库连接字符串
            var iotCloundContext = new FreeSqlBuilder().UseConnectionString(DataType.SqlServer, connectionString)
                .UseAutoSyncStructure(false).Build();

            var localEquipmentData = _context.Equipment.Where(x => true).IncludeMany(x => x.EquipmentProps).ToList();
            var localEquipmentTypes = _context.EquipmentType.Where(x => true).ToList();

            var iotEquipmentTypes = iotCloundContext.Queryable<EquipmentType>().AsTable((t, x) => "daq_equipment_Type").ToList();
            foreach (var item in localEquipmentData)
            {
                var equipmentTypeCode = localEquipmentTypes.Where(x => x.Id == item.EquipmentTypeId).First().Code;

                var iotEquipmentType = iotEquipmentTypes.Find(x => x.Code == equipmentTypeCode);
                var equipment = new Equipment
                {
                    Code = item.Code,
                    Name = item.Name,
                    EquipmentTypeId = iotEquipmentType.Id,
                    IP = item.IP,
                    DestinationArea = item.DestinationArea,
                    Description = item.Description,
                    Created = DateTime.Now,
                    ConnectName = item.ConnectName
                };

                iotCloundContext.Insert(equipment).AsTable($"daq_{nameof(Equipment)}").ExecuteAffrows();
                var equipmentId = iotCloundContext.Queryable<Equipment>().AsTable((t, x) => "daq_equipment").Where(x => x.Code == equipment.Code && x.DestinationArea == equipment.DestinationArea).First(x => x.Id);

                var iotEquipmentTypePropTemplates = iotCloundContext.Queryable<EquipmentTypePropTemplate>().Where(x => x.EquipmentTypeId == iotEquipmentType.Id).AsTable((t, x) => "daq_equipment_type_prop_template").ToList();
                var props = item.EquipmentProps.Select(x => new EquipmentProp
                {
                    EquipmentId = equipmentId,
                    EquipmentTypePropTemplateId = iotEquipmentTypePropTemplates.Find(t => t.Code == x.EquipmentTypePropTemplateCode).Id,
                    EquipmentTypePropTemplateCode = x.EquipmentTypePropTemplateCode,
                    Address = x.Address,
                    Remark = x.Remark,
                    Created = DateTime.Now,
                    ServerHandle = 0
                }).ToList();

                iotCloundContext.Insert(props).AsTable($"daq_equipment_prop").ExecuteAffrows();
            }
        }
    }
}