MES / DataAcquisition · Files

using HHECS.BllModel;
using HHECS.DAQShared.Common.Enums;
using HHECS.DAQShared.Models;
using HHECS.DAQWebClient.Dtos;
using HHECS.DAQWebClient.Hubs;
using HHECS.DAQWebClient.Models;
using Microsoft.AspNetCore.SignalR;
using System.Collections.Concurrent;

namespace HHECS.DAQWebClient.Services
{
    public class CommonService
    {
        private readonly IFreeSql _freeSql;
        private readonly IHubContext<DAQHub, IDAQHub> _hub;
        private readonly ILogger<CommonService> _logger;
        private readonly List<LogModel> logs = new List<LogModel>();

        /// <summary>
        /// 日志最大缓存数量
        /// </summary>
        private readonly int maxLogCacheCount = 30;

        private readonly ConsoleModel consoleModel = new ConsoleModel();
        private readonly static object lockObj = new object();

        public ConcurrentQueue<EquipmentDataQueue> EquipmentDataQueues { get; private set; } = new ConcurrentQueue<EquipmentDataQueue>();
        public List<Equipment> Equipments { get; private set; } = new List<Equipment>();

        public List<LogModel> Logs => logs.OrderByDescending(x => x.CreateTime).Take(maxLogCacheCount).ToList();

        public ConsoleModel ConsoleModel => consoleModel;

        /// <summary>
        /// 是否启动
        /// </summary>
        public bool IsStart => consoleModel.IsStart;

        /// <summary>
        /// 自动提交数据
        /// </summary>
        public bool AutoCommit => consoleModel.AutoCommit;

        /// <summary>
        /// 数据压缩
        /// </summary>
        public bool DataCompression => consoleModel.DataCompression;

        /// <summary>
        /// 是否为生产环境
        /// </summary>
        public bool IsProductionEnvironment { get; private set; }

        public CommonService(IFreeSql freeSql, IHubContext<DAQHub, IDAQHub> hub, ILogger<CommonService> logger)
        {
            _freeSql = freeSql;
            _hub = hub;
            _logger = logger;
            Initial();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        private void Initial()
        {
            try
            {
                var localConfigs = _freeSql.Queryable<LocalConfig>().ToList();
                var autoExecuteValue = localConfigs.Where(x => x.Code == ConfigType.AutoExecute.ToString()).Select(x => x.Value).FirstOrDefault();
                var autoCommitValue = localConfigs.Where(x => x.Code == ConfigType.AutoCommit.ToString()).Select(x => x.Value).FirstOrDefault();
                var dataCompressionValue = localConfigs.Where(x => x.Code == ConfigType.DataCompression.ToString()).Select(x => x.Value).FirstOrDefault();
                var isProductionEnvironmentValue = localConfigs.Where(x => x.Code == ConfigType.IsProductionEnvironment.ToString()).Select(x => x.Value).FirstOrDefault();

                _ = bool.TryParse(autoExecuteValue, out var autoExecute);
                _ = bool.TryParse(autoCommitValue, out var autoCommit);
                _ = bool.TryParse(dataCompressionValue, out var dataCompression);
                _ = bool.TryParse(isProductionEnvironmentValue, out var isProductionEnvironment);

                consoleModel.IsStart = autoExecute;
                consoleModel.AutoCommit = autoCommit;
                consoleModel.DataCompression = dataCompression;
                IsProductionEnvironment = isProductionEnvironment;
            }
            catch (Exception ex)
            {
                PrintLog(ex.Message, LogLevel.Error);
            }
        }

        public BllResult PrintLog(string message, LogLevel level = LogLevel.None)
        {
            try
            {
                lock (lockObj)
                {
                    var log = new LogModel
                    {
                        Message = message,
                        Level = level
                    };
                    var oldItem = logs.Where(x => x.Message.Equals(log.Message)).FirstOrDefault();
                    if (oldItem != null)
                    {
                        oldItem.CreateTime = DateTime.Now;
                    }
                    else
                    {
                        logs.Add(log);
                    }

                    if (logs.Count > maxLogCacheCount)
                    {
                        var lastItem = logs.OrderBy(x => x.CreateTime).First();
                        logs.Remove(lastItem);
                    }
                    _hub.Clients.All.PringtLog(log);
                    _logger.Log(log.Level, $"{log.CreateTime}：{log.Message}");
                    return BllResultFactory.Success();
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        public BllResult UpdateStartStatus(bool isStart)
        {
            try
            {
                var autoExecute = _freeSql.Queryable<LocalConfig>().Where(x => x.Code == ConfigType.AutoExecute.ToString()).First();
                if (autoExecute == null)
                {
                    autoExecute = new LocalConfig
                    {
                        Code = ConfigType.AutoExecute.ToString(),
                        Name = "自动执行",
                        Value = isStart.ToString(),
                        Created = DateTime.Now,
                    };
                    _freeSql.Insert(autoExecute).ExecuteAffrows();
                }
                else
                {
                    _freeSql.Update<LocalConfig>(autoExecute.Id).Set(x => new LocalConfig
                    {
                        Value = isStart ? bool.TrueString : bool.FalseString,
                        Updated = DateTime.Now,
                    }).ExecuteAffrows();
                }
                consoleModel.IsStart = isStart;
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        public BllResult UpdateAutoCommit(bool data)
        {
            try
            {
                var autoCommit = _freeSql.Queryable<LocalConfig>().Where(x => x.Code == ConfigType.AutoCommit.ToString()).First();
                if (autoCommit == null)
                {
                    autoCommit = new LocalConfig
                    {
                        Code = ConfigType.AutoCommit.ToString(),
                        Name = "自动上传",
                        Value = data.ToString(),
                        Created = DateTime.Now,
                    };
                    _freeSql.Insert(autoCommit).ExecuteAffrows();
                }
                else
                {
                    _freeSql.Update<LocalConfig>(autoCommit.Id).Set(x => new LocalConfig
                    {
                        Value = data ? bool.TrueString : bool.FalseString,
                        Updated = DateTime.Now,
                    }).ExecuteAffrows();
                }
                consoleModel.AutoCommit = data;
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        public BllResult UpdateDataCompression(bool data)
        {
            try
            {
                var dataCompression = _freeSql.Queryable<LocalConfig>().Where(x => x.Code == ConfigType.DataCompression.ToString()).First();
                if (dataCompression == null)
                {
                    dataCompression = new LocalConfig
                    {
                        Code = ConfigType.DataCompression.ToString(),
                        Name = "数据压缩",
                        Value = data.ToString(),
                        Created = DateTime.Now,
                    };
                    _freeSql.Insert(dataCompression).ExecuteAffrows();
                }
                else
                {
                    _freeSql.Update<LocalConfig>(dataCompression.Id).Set(x => new LocalConfig
                    {
                        Value = data ? bool.TrueString : bool.FalseString,
                        Updated = DateTime.Now,
                    }).ExecuteAffrows();
                }
                consoleModel.DataCompression = data;
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        public BllResult UpdateEnvironment(bool isProductionEnvironment)
        {
            try
            {
                var environment = _freeSql.Queryable<LocalConfig>().Where(x => x.Code == ConfigType.IsProductionEnvironment.ToString()).First();
                if (environment == null)
                {
                    environment = new LocalConfig
                    {
                        Code = ConfigType.IsProductionEnvironment.ToString(),
                        Name = "程序环境",
                        Value = isProductionEnvironment.ToString(),
                        Created = DateTime.Now,
                    };
                    _freeSql.Insert(environment).ExecuteAffrows();
                }
                else
                {
                    _freeSql.Update<LocalConfig>(environment.Id).Set(x => new LocalConfig
                    {
                        Value = isProductionEnvironment ? bool.TrueString : bool.FalseString,
                        Updated = DateTime.Now,
                    }).ExecuteAffrows();
                }
                IsProductionEnvironment = isProductionEnvironment;
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        public BllResult InitialEquipmentData()
        {
            try
            {
                var currentArea = _freeSql.Queryable<LocalConfig>().Where(x => x.Code == ConfigType.Area.ToString()).First(x => x.Value);
                if (string.IsNullOrWhiteSpace(currentArea))
                {
                    Equipments = _freeSql.Queryable<Equipment>().Where(x => !x.Disable).ToList();
                }
                else
                {
                    Equipments = _freeSql.Queryable<Equipment>().Where(x => !x.Disable && x.DestinationArea == currentArea).ToList();
                }
                if (Equipments.Count == 0)
                {
                    return BllResultFactory.Error($"设备数据为空，请配置数据后操作！");
                }

                var equipmentIds = Equipments.Select(x => x.Id).ToList();
                var equipmentTypeIds = Equipments.Select(x => x.EquipmentTypeId).Distinct().ToList();

                var equipmentProps = _freeSql.Queryable<EquipmentProp>().Where(x => equipmentIds.Contains(x.EquipmentId)).ToList();
                var equipmentTypes = _freeSql.Queryable<EquipmentType>().Where(x => equipmentTypeIds.Contains(x.Id)).ToList();
                var equipmentTypePropTemplates = _freeSql.Queryable<EquipmentTypePropTemplate>().Where(x => equipmentTypeIds.Contains(x.EquipmentTypeId)).ToList();
                //组合逻辑外键
                Equipments.ForEach(t =>
                {
                    t.EquipmentType = equipmentTypes.FirstOrDefault(i => i.Id == t.EquipmentTypeId)!;
                    t.EquipmentProps = equipmentProps.Where(i => i.EquipmentId == t.Id).ToList();
                });
                equipmentProps.ForEach(t =>
                {
                    t.Equipment = Equipments.FirstOrDefault(i => i.Id == t.EquipmentId)!;
                });
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        /// <summary>
        /// 获取报警信息
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public (string, List<string>) GetEquipmentAlarmInfo(Equipment equipment)
        {
            try
            {
                var status = GetEquipmentStatus(equipment);
                //无报警
                if (status != EquipmentStatus.Failure)
                {
                    return (string.Empty, new List<string>());
                }

                _ = Enum.TryParse<EquipmentTypeConst>(equipment.EquipmentType.Code, out var equipmentTypeCode);
                //存在报警
                var mainAlarm = string.Empty;
                var detailAlarms = new List<string>();

                if (equipmentTypeCode == EquipmentTypeConst.AGVForklift)
                {
                    return (mainAlarm, detailAlarms);
                }

                //其他设备通用逻辑
                var mainAlarmPropCode = equipmentTypeCode switch
                {
                    EquipmentTypeConst.SingleForkSRM => SRMProps.TotalError.ToString(),
                    EquipmentTypeConst.DoubleForkSRM => SRMProps.TotalError.ToString(),
                    EquipmentTypeConst.SingleForkSSRM => SRMProps.TotalError.ToString(),
                    EquipmentTypeConst.SingleForkSSRMV132 => SRMProps.TotalError.ToString(),
                    EquipmentTypeConst.WeldRobot => RobotProp.Alarm.ToString(),
                    EquipmentTypeConst.RGVStation => RGVStationProps.Fault.ToString(),
                    EquipmentTypeConst.StationMonitor => StationMonitorProp.StationError.ToString(),
                    EquipmentTypeConst.Hoist => HoistProps.HoistStatus.ToString(),
                    _ => string.Empty,
                };

                if (string.IsNullOrWhiteSpace(mainAlarmPropCode))
                {
                    return (mainAlarm, detailAlarms);
                }

                var mainAlarmProp = equipment.EquipmentProps.Where(x => x.Code == mainAlarmPropCode).FirstOrDefault();
                //存在报警
                if (mainAlarmProp != null && mainAlarmProp.Value == bool.TrueString)
                {
                    mainAlarm = mainAlarmProp.MonitorFailure;
                    var props = equipment.EquipmentProps.Where(x => x.PropType == EquipmentPropType.PLCMonitorAddress).ToList();
                    detailAlarms = props.Where(x =>
                    {
                        if (x.MonitorCompareValue == x.Value)
                        {
                            return false;
                        }
                        return true;
                    }).Select(x => x.MonitorFailure).ToList();
                }

                return (mainAlarm, detailAlarms);
            }
            catch (Exception)
            {
                return (string.Empty, new List<string>());
            }
        }

        /// <summary>
        /// 获取设备状态
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public EquipmentStatus GetEquipmentStatus(Equipment equipment)
        {
            try
            {
                _ = Enum.TryParse<EquipmentTypeConst>(equipment.EquipmentType.Code, out var equipmentType);
                var srmCodes = new List<EquipmentTypeConst>
                {
                    EquipmentTypeConst.SingleForkSSRM,
                    EquipmentTypeConst.SingleForkSSRMV2,
                    EquipmentTypeConst.DoubleForkSRM,
                    EquipmentTypeConst.DoubleForkSRMV2,
                    EquipmentTypeConst.SingleForkSSRM,
                    EquipmentTypeConst.SingleForkSSRMV2,
                    EquipmentTypeConst.SingleForkSSRMV132,
                }.Select(x => x.ToString()).ToList();

                //堆垛机
                if (srmCodes.Contains(equipment.EquipmentType.Code))
                {
                    var totalError = equipment[SRMProps.TotalError.ToString()].Value;
                    var operationModel = equipment[SRMProps.OperationModel.ToString()].Value;
                    var fork1TaskExcuteStatus = equipment[SRMProps.Fork1TaskExcuteStatus.ToString()].Value;
                    //故障
                    if (totalError == bool.TrueString)
                    {
                        //维修状态下，不统计报警
                        if (operationModel == SRMOperationModel.Maintain.ToString())
                        {
                            return EquipmentStatus.Free;
                        }
                        return EquipmentStatus.Failure;
                    }

                    //运行
                    if (operationModel == ((int)SRMOperationModel.Online).ToString() && fork1TaskExcuteStatus == ((int)SRMTaskExcuteStatus.TaskExecuting).ToString())
                    {
                        return EquipmentStatus.Running;
                    }

                    //空闲
                    return EquipmentStatus.Free;
                }

                //焊接机器人
                if (equipmentType == EquipmentTypeConst.WeldRobot)
                {
                    var bootFlag = equipment[RobotProp.BootFlag.ToString()].Value;
                    var totalError = equipment[RobotProp.Alarm.ToString()].Value;
                    var workMode = equipment[RobotProp.Work_Mode.ToString()].Value;
                    var workTime = equipment[RobotProp.Work_Time.ToString()].Value;
                    var workFlag = equipment[RobotProp.WorkFlag.ToString()].Value;
                    if (bootFlag != bool.TrueString)
                    {
                        return EquipmentStatus.Offline;
                    }

                    //故障，T1、T2模式不记录报警
                    if (totalError == bool.TrueString && workTime != "1" && workTime != "2")
                    {
                        return EquipmentStatus.Failure;
                    }

                    //运行
                    if (workMode == "3" && (workFlag == bool.TrueString || workTime == bool.TrueString))
                    {
                        return EquipmentStatus.Running;
                    }

                    //待机
                    return EquipmentStatus.Free;
                }

                //AGV
                if (equipmentType == EquipmentTypeConst.AGVForklift)
                {
                    return EquipmentStatus.Offline;
                }

                //站台监控
                if (equipmentType == EquipmentTypeConst.StationMonitor)
                {
                    var totalError = equipment[StationMonitorProp.StationError.ToString()].Value;
                    var stationCorotation = false;
                    var stationReverse = false;

                    //故障
                    if (totalError == bool.TrueString)
                    {
                        return EquipmentStatus.Failure;
                    }

                    if (equipment.EquipmentProps.Exists(x => x.Code == StationMonitorProp.StationCorotation.ToString()))
                    {
                        _ = bool.TryParse(equipment[StationMonitorProp.StationCorotation.ToString()].Value, out stationCorotation);
                    }

                    if (equipment.EquipmentProps.Exists(x => x.Code == StationMonitorProp.StationReverse.ToString()))
                    {
                        _ = bool.TryParse(equipment[StationMonitorProp.StationReverse.ToString()].Value, out stationReverse);
                    }

                    //运行
                    if (stationCorotation || stationReverse)
                    {
                        return EquipmentStatus.Running;
                    }

                    //待机
                    return EquipmentStatus.Free;
                }

                //提升机
                if (equipmentType == EquipmentTypeConst.Hoist)
                {
                    var hoistStatus = equipment[HoistProps.HoistStatus.ToString()].Value;
                    if (string.IsNullOrWhiteSpace(hoistStatus))
                    {
                        return EquipmentStatus.Offline;
                    }

                    //故障
                    if (hoistStatus == "1")
                    {
                        return EquipmentStatus.Failure;
                    }
                    if (hoistStatus == "6")
                    {
                        return EquipmentStatus.Running;
                    }

                    return EquipmentStatus.Free;
                }

                //RGV站台
                if (equipmentType == EquipmentTypeConst.RGVStation)
                {
                    var totalError = equipment[RGVStationProps.Fault.ToString()].Value;
                    var autoMode = equipment[RGVStationProps.AutoMode.ToString()].Value;
                    var running = equipment[RGVStationProps.Running.ToString()].Value;
                    var stop = equipment[RGVStationProps.Stop.ToString()].Value;
                    var manual = equipment[RGVStationProps.Manual.ToString()].Value;
                    var airborne = equipment[RGVStationProps.Airborne.ToString()].Value;
                    var maintain = equipment[RGVStationProps.Maintain.ToString()].Value;

                    //无数据，视为离线
                    if (string.IsNullOrWhiteSpace(totalError))
                    {
                        return EquipmentStatus.Offline;
                    }

                    //故障
                    if (totalError == bool.TrueString)
                    {
                        return EquipmentStatus.Failure;
                    }

                    //运行
                    if (autoMode == bool.TrueString && running == bool.TrueString)
                    {
                        return EquipmentStatus.Running;
                    }

                    //待机
                    return EquipmentStatus.Free;
                }

                return EquipmentStatus.None;
            }
            catch (Exception)
            {
                return EquipmentStatus.None;
            }
        }
    }
}