Example #1
0
        public static ValidationCheckResult CheckDecimalPlaces(ValidationCheckParameters <FD, FA, FV, T, D> parameters)
        {
            var decimalPlacesRule = parameters.GetConfigurations(FieldConfigurationType.DecimalPlaces).FirstOrDefault();

            if (decimalPlacesRule == null || parameters.Field.Value == null)
            {
                return(new ValidationCheckResult());
            }

            var decimalPlacesValue = decimalPlacesRule.ValueInteger ?? 0;

            if (decimalPlacesValue < 0)
            {
                decimalPlacesValue = 0;
            }

            if (decimalPlacesValue >= 0)
            {
                var faktor = Convert.ToInt32(Math.Pow(10, decimalPlacesValue));

                if (parameters.Field.Type == typeof(float))
                {
                    var valueFloat = (float)parameters.Field.Value;
                    valueFloat *= faktor;

                    if (Math.Truncate(valueFloat) != valueFloat)
                    {
                        return(GetErrorResult(ValidationErrorType.DataTypeFloatOrDouble, parameters.Field.Id));
                    }
                }
                else if (parameters.Field.Type == typeof(double))
                {
                    var valueDouble = (double)parameters.Field.Value;
                    valueDouble *= faktor;

                    if (Math.Truncate(valueDouble) != valueDouble)
                    {
                        return(GetErrorResult(ValidationErrorType.DataTypeFloatOrDouble, parameters.Field.Id));
                    }
                }
                else if (parameters.Field.Type == typeof(decimal))
                {
                    var valueDecimal = (decimal)parameters.Field.Value;
                    valueDecimal *= faktor;

                    if (Math.Truncate(valueDecimal) != valueDecimal)
                    {
                        return(GetErrorResult(ValidationErrorType.DataTypeDecimal, parameters.Field.Id));
                    }
                }
            }

            return(new ValidationCheckResult());
        }
Example #2
0
        private static ValidationCheckResult CheckRangeValueInteger(ValidationCheckParameters parameters, PropertyInfo propertyInfoFrom, PropertyInfo propertyInfoTo)
        {
            var valueFromObject = propertyInfoFrom.GetValue(parameters.Model);
            var valueToObject   = propertyInfoTo.GetValue(parameters.Model);
            var valueFrom       = valueFromObject == null ? (int?)null : Convert.ToInt32(valueFromObject);
            var valueTo         = valueToObject == null ? (int?)null : Convert.ToInt32(valueToObject);

            if (CheckRangeValue(valueFrom, valueTo, parameters.AllowNull))
            {
                return(new ValidationCheckResult());
            }

            return(GetErrorResult(ValidationErrorType.DataTypeInteger, propertyInfoFrom.Name, propertyInfoTo.Name));
        }
Example #3
0
        public static ValidationCheckResult CheckRangeValue(ValidationCheckParameters parameters, PropertyInfo propertyInfoFrom, PropertyInfo propertyInfoTo)
        {
            var datatypeFrom = propertyInfoFrom.GetDataType();
            var datatypeTo   = propertyInfoTo.GetDataType();

            if (datatypeFrom != datatypeTo)
            {
                return(GetErrorResult(ValidationErrorType.DataTypesNotEqual, propertyInfoFrom.Name, propertyInfoTo.Name));
            }

            if (datatypeFrom == typeof(float))
            {
                return(CheckRangeValueFloat(parameters, propertyInfoFrom, propertyInfoTo));
            }

            if (datatypeFrom == typeof(double))
            {
                return(CheckRangeValueDouble(parameters, propertyInfoFrom, propertyInfoTo));
            }

            if (datatypeFrom == typeof(decimal))
            {
                return(CheckRangeValueDecimal(parameters, propertyInfoFrom, propertyInfoTo));
            }

            if (datatypeFrom == typeof(int) || parameters.DataType.IsEnum)
            {
                return(CheckRangeValueInteger(parameters, propertyInfoFrom, propertyInfoTo));
            }

            if (datatypeFrom == typeof(long))
            {
                return(CheckRangeValueLong(parameters, propertyInfoFrom, propertyInfoTo));
            }

            if (datatypeFrom == typeof(DateTime))
            {
                return(CheckRangeValueDateTime(parameters, propertyInfoFrom, propertyInfoTo));
            }

            return(GetErrorResult(ValidationErrorType.DataTypeNotSupported, propertyInfoFrom.Name, propertyInfoTo.Name));
        }