Validators.cs

using System;
using System.Text.RegularExpressions;
using NanoXLSX.Exceptions;
using FormatException = NanoXLSX.Exceptions.FormatException;
 
 
namespace NanoXLSX.Utils
{
    public static class Validators
    {

        // <exception cref = "StyleException" > A StyleException is thrown if an invalid hex value is passed</exception>
        public static void ValidateGenericColor(string hexCode, bool allowEmpty = false)
        {
            string argbMessage = ValidateColorInternal(hexCode, true, allowEmpty);
            string rgbMessage = null;
            if (argbMessage != null)
            {
                rgbMessage = ValidateColorInternal(hexCode, false, allowEmpty);
                if (rgbMessage != null)
                {
                    throw new StyleException(argbMessage);
                }
            }
        }

        public static void ValidateColor(string hexCode, bool useAlpha, bool allowEmpty = false)
        {
            string message = ValidateColorInternal(hexCode, useAlpha, allowEmpty);
            if (message != null)
            {
                throw new StyleException(message);
            }
        }

        public static void ValidateCellAddressExpression(string expression, Cell.AddressScope scope = Cell.AddressScope.Any)
        {
            bool isCellAddress = false;
            bool isRange = false;
            Exception lastException = null;
            try
            {
                Cell.ResolveCellCoordinate(expression);
                isCellAddress = true;
            }
            catch (Exception ex)
            {
                if (scope == Cell.AddressScope.SingleAddress)
                {
                    throw new FormatException(ex.Message, ex); // No further checks necessary
                }
                lastException = ex;
            }
            try
            {
                Cell.ResolveCellRange(expression);
                isRange = true;
            }
            catch (Exception ex)
            {
                if (scope == Cell.AddressScope.Range)
                {
                    throw new FormatException(ex.Message, ex); // No further checks necessary
                }
                lastException = ex;
            }
            if (scope == Cell.AddressScope.Range && isCellAddress && isRange)
            {
                System.FormatException innerException = new System.FormatException("The expression (" + expression + ") is a single cell address, but a cell range was expected");
                throw new FormatException(innerException.Message, innerException);
            }
            else if (scope == Cell.AddressScope.Any && !isCellAddress && !isRange)
            {
                throw new FormatException(lastException.Message, lastException); // Not a cell or range
            }
            else if (scope == Cell.AddressScope.Invalid && (isCellAddress || isRange))
            {
                throw new FormatException("The passed expression is valid cell address or range, but the validation was explicitly inverted");
            }
        }

        public static void ValidateWorksheetName(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new FormatException("the worksheet name must be between 1 and " + Worksheet.MaxWorksheetNameLength + " characters");
            }
            if (name.Length > Worksheet.MaxWorksheetNameLength)
            {
                throw new FormatException("the worksheet name must be between 1 and " + Worksheet.MaxWorksheetNameLength + " characters");
            }
            Regex regex = new Regex(@"[\‍[\‍]\*\?/\\‍]");
            Match match = regex.Match(name);
            if (match.Captures.Count > 0)
            {
                throw new FormatException(@"the worksheet name must not contain the characters [  ]  * ? / \ ");
            }
        }

        private static string ValidateColorInternal(string hexCode, bool useAlpha, bool allowEmpty)
        {
            if (string.IsNullOrEmpty(hexCode))
            {
                if (allowEmpty)
                {
                    return null;
                }
                return "The color expression cannot be null or empty";
            }
 
            int length = useAlpha ? 8 : 6;
            if (hexCode.Length != length)
            {
                return "The value '" + hexCode + "' is invalid. A valid value must contain " + length + " hex characters";
            }
            if (!Regex.IsMatch(hexCode, "[a-fA-F0-9]{6,8}"))
            {
                return "The expression '" + hexCode + "' is not a valid hex value";
            }
            return null;
        }
    }
}