private void UploadSensorData()
    {
        var sensorData       = sensorDataProvider.GetAllData();
        var sensorDataString = SensorDataConverter.SensorDataListToString(sensorData);

        BackendService.Instance.UploadSensorDataFile(sensorDataString);
    }
        /// <summary>
        /// The method should return true if validation should continue, or false to immediately abort.
        /// Any modifications that you made to the ValidationResult will be returned to the user.
        /// Checks the sensor is not null and it configuration is exists and the sensor enabled.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        protected override bool PreValidate(ValidationContext <SensorDataRequest> context, ValidationResult result)
        {
            var sensorDataRequest = context.InstanceToValidate;

            if (sensorDataRequest.IsNullOrEmpty())
            {
                return(Error($"Please ensure a {nameof(SensorDataRequest)} was supplied.", null, ref result));
            }

            #region Check The Sensor Configuration
            if (!_sensorConfiguration.TryGetSensorConfiguration(context.InstanceToValidate.SensorTypeId, out var sensor))
            {
                return(Error("No one configuration found.", StructuredData, ref result, sensorDataRequest));
            }

            if (!sensor.IsEnabled)
            {
                return(Error("The sensor is not enabled.", StructuredDataAndConfig, ref result, sensorDataRequest, sensor));
            }
            #endregion

            _sensor = sensor;

            var converter = new SensorDataConverter(_sensor);
            try
            {
                sensorDataRequest.NormalValue = converter.NormalValueFrom(sensorDataRequest.Value);
            }
            catch (ArithmeticException e)
            {
                return(Error(e.Message, StructuredDataAndConfig, ref result, sensorDataRequest, sensor));
            }

            return(true);
        }
        public void NormalValueFromExceptionTest(decimal value)
        {
            var sensor = new Sensor
            {
                MinValue = value,
                MaxValue = value,
            };

            var sensorDataConverter = new SensorDataConverter(sensor);

            Action action = () => sensorDataConverter.NormalValueFrom(It.IsAny <decimal>());

            action.Should().Throw <ArithmeticException>().WithMessage("Abnormal sensor configuration.");
        }
        public void NormalValueFromTest(byte precision, decimal minValue, decimal maxValue, decimal minNormalValue, decimal maxNormalValue, decimal value, decimal expectedNormalValue)
        {
            var sensor = new Sensor
            {
                MinValue       = minValue,
                MaxValue       = maxValue,
                MinNormalValue = minNormalValue,
                MaxNormalValue = maxNormalValue,
                Precision      = precision
            };

            var sensorDataConverter = new SensorDataConverter(sensor);

            var normalValue = sensorDataConverter.NormalValueFrom(value);

            normalValue.Should().Be(expectedNormalValue);
        }