private string ConvertStatus(HealthStatusEnum status)
        {
            string result = "";

            switch (status)
            {
            case HealthStatusEnum.Unknown:
                result = UNKONW;
                break;

            case HealthStatusEnum.Normal:
                result = NORMAL;
                break;

            case HealthStatusEnum.Warning:
                result = WARING;
                break;

            case HealthStatusEnum.Error:
                result = ERROR;
                break;

            default:
                break;
            }

            return(result);
        }
        private HealthStatusEnum AnalysisMotorStatus(DeviceDetail model)
        {
            HealthStatusEnum result       = HealthStatusEnum.Unknown;
            DeviceDetail     deviceDetail = model;

            if (deviceDetail.UpMotor && deviceDetail.DownMotor && deviceDetail.StopMotor)
            {
                result = HealthStatusEnum.Normal;
            }
            else
            {
                result = HealthStatusEnum.Error;

                deviceDetail.MotorAdvice = "电机操作异常,无法正常运行。";

                if (!deviceDetail.UpMotor)
                {
                    deviceDetail.MotorAdvice += "上升电机操作失败。";
                }

                if (!deviceDetail.DownMotor)
                {
                    deviceDetail.MotorAdvice += "下降电机操作失败。";
                }

                if (!deviceDetail.StopMotor)
                {
                    deviceDetail.MotorAdvice += "停止电机操作失败。";
                }
            }

            return(result);
        }
        private HealthStatusEnum AnalysisValveStatus(DeviceDetail model)
        {
            HealthStatusEnum result       = HealthStatusEnum.Unknown;
            DeviceDetail     deviceDetail = model;

            if (deviceDetail.OpenValve && deviceDetail.CloseValve && deviceDetail.AutoValve)
            {
                result = HealthStatusEnum.Normal;
            }
            else
            {
                result = HealthStatusEnum.Error;

                deviceDetail.ValveAdvice = "阀门操作异常,无法正常运行。";

                if (!deviceDetail.OpenValve)
                {
                    deviceDetail.ValveAdvice += "打开阀门操作失败。";
                }

                if (!deviceDetail.CloseValve)
                {
                    deviceDetail.ValveAdvice += "关闭阀门操作失败。";
                }

                if (!deviceDetail.AutoValve)
                {
                    deviceDetail.ValveAdvice += "自动控制阀门操作失败。";
                }
            }

            return(result);
        }
 public bool Equals(HealthStatusEnum obj)
 {
     if ((object)obj == null)
     {
         return(false);
     }
     return(StringComparer.OrdinalIgnoreCase.Equals(this.Value, obj.Value));
 }
    public void Infect()
    {
        status = HealthStatusEnum.infected;
        InfectionManager.Instance.AddNewInfected(this);
        gameObject.tag = "Infected";
        myVirus.setVirusActive(true);

        //WIP
        GetComponent <SpriteRenderer>().color = Color.green;
        GetComponent <HumanMovement>().GotInfected();
    }
        private HealthStatusEnum AnalysisPumpStatus(DeviceDetail model)
        {
            HealthStatusEnum result       = HealthStatusEnum.Normal;
            DeviceDetail     deviceDetail = model;

            if ((DateTime.Now - deviceDetail.LastChangeOilTime).TotalHours > deviceDetail.ChangOilTime)
            {
                result = HealthStatusEnum.Warning;

                deviceDetail.PumpAdvice = "距离上次更换泵油时间过长,建议更换泵油。";
            }

            return(result);
        }
        private HealthStatusEnum AnalysisStoveStatus(DeviceDetail model)
        {
            HealthStatusEnum result       = HealthStatusEnum.Unknown;
            DeviceDetail     deviceDetail = model;

            double tempDiff = deviceDetail.StoveTempMax - deviceDetail.StoveTempMin;

            if (deviceDetail.StartStove && deviceDetail.StopStove && deviceDetail.HoldStove && tempDiff <= DIFFERENTTEMP)
            {
                result = HealthStatusEnum.Normal;
            }
            else if (!deviceDetail.StartStove || !deviceDetail.StopStove || !deviceDetail.HoldStove)
            {
                result = HealthStatusEnum.Error;
                deviceDetail.StoveAdvice = "加热炉操作异常,无法正常运行。";

                if (!deviceDetail.StartStove)
                {
                    deviceDetail.StoveAdvice += "开始加热操作失败。";
                }

                if (!deviceDetail.StopStove)
                {
                    deviceDetail.StoveAdvice += "停止加热操作失败。";
                }

                if (!deviceDetail.HoldStove)
                {
                    deviceDetail.StoveAdvice += "保持温度操作失败。";
                }
            }
            else
            {
                result = HealthStatusEnum.Warning;
                deviceDetail.StoveAdvice = "加热炉保持温度稳定性较差,会影响测试结果。";
            }

            return(result);
        }
        private HealthStatusEnum AnalysisSensorStatus(DeviceDetail model)
        {
            HealthStatusEnum result       = HealthStatusEnum.Unknown;
            DeviceDetail     deviceDetail = model;

            //真空压力差值
            double vacuumDiff = Math.Abs(deviceDetail.VacuumPress);
            //常压压力差值
            double airDiff = Math.Abs(deviceDetail.AirPress - deviceDetail.StandardAirPress);
            //稳定度
            double stableDiff = deviceDetail.AirPressMax - deviceDetail.AirPressMin;

            if (vacuumDiff <= DIFFERENTPRESS && airDiff <= DIFFERENTPRESS && stableDiff <= STABLEPRESS)
            {
                result = HealthStatusEnum.Normal;
            }
            else
            {
                result = HealthStatusEnum.Warning;

                if (vacuumDiff > LOWGASNORMAL)
                {
                    deviceDetail.SenorAdvice = "真空条件下读数不准确。";
                }

                if (airDiff > HIGHGASWARINGL)
                {
                    deviceDetail.SenorAdvice += "常压条件下读数不准确。";
                }

                if (stableDiff > STABLEPRESS)
                {
                    deviceDetail.SenorAdvice += "读数稳定性较差。";
                }
            }

            return(result);
        }
        private HealthStatusEnum AnalysisGasStatus(DeviceDetail model)
        {
            HealthStatusEnum result       = HealthStatusEnum.Unknown;
            DeviceDetail     deviceDetail = model;

            //低压气密性
            double lowGas = (deviceDetail.LowPressEndP - deviceDetail.LowPressStartP) / deviceDetail.LowPressDuring;

            //高压气密性
            double highGas = (deviceDetail.HighPressEndP - deviceDetail.HighPressStartP) / deviceDetail.HighPressDuring;

            if (lowGas <= LOWGASNORMAL && highGas <= HIGHGASNORMAL)
            {
                result = HealthStatusEnum.Normal;
            }
            else if (lowGas > LOWGASWARING || highGas > HIGHGASWARINGL)
            {
                result = HealthStatusEnum.Error;
                deviceDetail.GasAdvice = "气密性异常,会造成测试不准确。";
            }
            else
            {
                result = HealthStatusEnum.Warning;

                if (lowGas <= LOWGASNORMAL)
                {
                    deviceDetail.GasAdvice = "低压气密性较差。";
                }

                if (highGas <= HIGHGASWARINGL)
                {
                    deviceDetail.GasAdvice += "高压气密性较差。";
                }
            }

            return(result);
        }
        private HealthStatusEnum AnalysisDeviceStatus(DeviceAnalysisViewModel model)
        {
            HealthStatusEnum result = HealthStatusEnum.Normal;

            List <string> list = new List <string>();

            list.Add(model.GasStatus);
            list.Add(model.SensorStatus);
            list.Add(model.PumpStatus);
            list.Add(model.MotorStatus);
            list.Add(model.ValueStatus);
            list.Add(model.StoveStatus);

            if (list.Contains(ERROR))
            {
                result = HealthStatusEnum.Error;
            }
            else if (list.Contains(WARING))
            {
                result = HealthStatusEnum.Warning;
            }

            return(result);
        }