示例#1
0
        public static string FormatComparator(ComparatorEnum comparator)
        {
            switch (comparator)
            {
            case ComparatorEnum.In:
            case ComparatorEnum.SemVerIn:
                return("IS ONE OF");

            case ComparatorEnum.NotIn:
            case ComparatorEnum.SemVerNotIn:
                return("IS NOT ONE OF");

            case ComparatorEnum.Contains:
                return("CONTAINS");

            case ComparatorEnum.NotContains:
                return("DOES NOT CONTAIN");

            case ComparatorEnum.SemVerLessThan:
            case ComparatorEnum.NumberLessThan:
                return("<");

            case ComparatorEnum.SemVerLessThanEqual:
            case ComparatorEnum.NumberLessThanEqual:
                return("<=");

            case ComparatorEnum.SemVerGreaterThan:
            case ComparatorEnum.NumberGreaterThan:
                return(">");

            case ComparatorEnum.SemVerGreaterThanEqual:
            case ComparatorEnum.NumberGreaterThanEqual:
                return(">=");

            case ComparatorEnum.NumberEqual:
                return("=");

            case ComparatorEnum.NumberNotEqual:
                return("!=");

            case ComparatorEnum.SensitiveOneOf:
                return("IS ONE OF (Sensitive)");

            case ComparatorEnum.SensitiveNotOneOf:
                return("IS NOT ONE OF (Sensitive)");

            default:
                return(comparator.ToString());
            }
        }
示例#2
0
        private static bool EvaluateNumber(string s1, string s2, ComparatorEnum comparator)
        {
            if (!double.TryParse(s1.Replace(',', '.'), NumberStyles.Any, CultureInfo.InvariantCulture, out double d1) ||
                !double.TryParse(s2.Replace(',', '.'), NumberStyles.Any, CultureInfo.InvariantCulture, out double d2))
            {
                return(false);
            }

            switch (comparator)
            {
            case ComparatorEnum.NumberEqual:

                return(d1 == d2);

            case ComparatorEnum.NumberNotEqual:

                return(d1 != d2);

            case ComparatorEnum.NumberLessThan:

                return(d1 < d2);

            case ComparatorEnum.NumberLessThanEqual:

                return(d1 <= d2);

            case ComparatorEnum.NumberGreaterThan:

                return(d1 > d2);

            case ComparatorEnum.NumberGreaterThanEqual:

                return(d1 >= d2);

            default:
                break;
            }

            return(false);
        }
示例#3
0
        private static bool EvaluateSemVer(string s1, string s2, ComparatorEnum comparator)
        {
            if (SemVersion.TryParse(s1?.Trim(), out SemVersion v1, true))
            {
                s2 = string.IsNullOrWhiteSpace(s2) ? string.Empty : s2.Trim();

                switch (comparator)
                {
                case ComparatorEnum.SemVerIn:

                    var rsvi = s2
                               .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
                               .Select(s =>
                    {
                        if (SemVersion.TryParse(s.Trim(), out SemVersion ns, true))
                        {
                            return(ns);
                        }

                        return(null);
                    })
                               .ToList();

                    return(!rsvi.Contains(null) && rsvi.Any(v => v.PrecedenceMatches(v1)));

                case ComparatorEnum.SemVerNotIn:

                    var rsvni = s2
                                .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
                                .Select(s =>
                    {
                        if (SemVersion.TryParse(s?.Trim(), out SemVersion ns, true))
                        {
                            return(ns);
                        }

                        return(null);
                    })
                                .ToList();

                    return(!rsvni.Contains(null) && !rsvni.Any(v => v.PrecedenceMatches(v1)));

                case ComparatorEnum.SemVerLessThan:

                    if (SemVersion.TryParse(s2, out SemVersion v20, true))
                    {
                        return(v1.CompareByPrecedence(v20) < 0);
                    }

                    break;

                case ComparatorEnum.SemVerLessThanEqual:

                    if (SemVersion.TryParse(s2, out SemVersion v21, true))
                    {
                        return(v1.CompareByPrecedence(v21) <= 0);
                    }

                    break;

                case ComparatorEnum.SemVerGreaterThan:

                    if (SemVersion.TryParse(s2, out SemVersion v22, true))
                    {
                        return(v1.CompareByPrecedence(v22) > 0);
                    }

                    break;

                case ComparatorEnum.SemVerGreaterThanEqual:

                    if (SemVersion.TryParse(s2, out SemVersion v23, true))
                    {
                        return(v1.CompareByPrecedence(v23) >= 0);
                    }

                    break;

                default:
                    break;
                }
            }

            return(false);
        }