11252482566

Committed 09 Oct 2024 09:47AM UTC coverage: 57.377% (-0.003%) from 57.38%

Build # 11252482566

Build Type

push

github

Committed by

JFriel

Commit Message

add logs

Run Details

11208 of 21044 branches covered (53.26%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

31727 of 53785 relevant lines covered (58.99%)

8195.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.0

/Rdmp.Core/Validation/Validator.cs

// Copyright (c) The University of Dundee 2018-2019
// This file is part of the Research Data Management Platform (RDMP).
// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using Rdmp.Core.Repositories;
using Rdmp.Core.Validation.Constraints;
using Rdmp.Core.Validation.Constraints.Primary;
using Rdmp.Core.Validation.Constraints.Secondary;
using Rdmp.Core.Validation.Constraints.Secondary.Predictor;

namespace Rdmp.Core.Validation;

/// <summary>
/// The Validator is the main entry point into this API. A client would typically create a Validator instance and then
/// add a number of ItemValidators to it.  Alternatively you can use the static method LoadFromXml.  Ensure you set
/// LocatorForXMLDeserialization.
/// 
/// <para>Generally, there are two phases of interaction with a Validator:</para>
/// 
/// <para>1. Design Time
/// During this phase, the client will instantiate and set up a Validator. The Check() method can be called to check for
/// any type incompatibilities prior to running the actual Validate() method.</para>
/// 
/// <para>2. Run Time
/// The Validation(o) method is called, applying the previously set up validation rules to the supplied domain object (o).</para>
/// 
/// <para>Note: As of this writing the Dictionary-based method is under active development, whereas the Object-based method
/// is not adequately developed or tested . PLEASE USE THE DICTIONARY method FOR NOW!</para>
/// </summary>
[XmlRoot("Validator")]
public class Validator
{
    private object _domainObject;
    private Dictionary<string, object> _domainObjectDictionary;

    /// <summary>
    /// Validation rules can reference objects e.g. StandardRegex.  This static property indicates where to get the available instances available
    /// for selection (the Catalogue database).
    /// </summary>
    public static ICatalogueRepositoryServiceLocator LocatorForXMLDeserialization;

    public List<ItemValidator> ItemValidators { get; set; }


    public Validator()
    {
        ItemValidators = new List<ItemValidator>();
    }

    /// <summary>
    /// Adds an ItemValidator to the Validator, specifying the target property (in the object to be validated) and
    /// the type that we expect this property to have. The type is used later in the Check() method. See below..
    /// </summary>
    /// <param name="itemValidator"></param>
    /// <param name="targetProperty"></param>
    /// <param name="expectedType"></param>
    public void AddItemValidator(ItemValidator itemValidator, string targetProperty, Type expectedType)
    {
        if (ItemValidators.Any(iv => iv.TargetProperty.Equals(targetProperty)))
            throw new ArgumentException(
                "TargetProperty is already targeted by another ItemValidator in the collection");

        itemValidator.TargetProperty = targetProperty;
        itemValidator.ExpectedType = expectedType;

        ItemValidators.Add(itemValidator);
    }

    /// <summary>
    /// Returns the ItemValidator associated with the given key.
    /// </summary>
    /// <param name="key"></param>
    /// <returns>An Itemvalidator reference, or null if no match found for the supplied key</returns>
    public ItemValidator GetItemValidator(string key)
    {
        try
        {
            return ItemValidators.SingleOrDefault(iv => iv.TargetProperty.Equals(key));
        }
        catch (InvalidOperationException)
        {
            return null;
        }
    }

    /// <summary>
    /// Removes a given (key) ItemValidator from the collection.
    /// </summary>
    /// <param name="key"></param>
    /// <returns>true if the removal succeeded, false otherwise</returns>
    public bool RemoveItemValidator(string key)
    {
        ItemValidator toRemove;

        try
        {
            toRemove = ItemValidators.First(iv => iv.TargetProperty.Equals(key));
        }
        catch (InvalidOperationException)
        {
            return false;
        }


        return ItemValidators.Remove(toRemove);
    }

    /// <summary>
    /// Validate against the supplied domain object, which takes the form of a generic object.
    /// </summary>
    /// <param name="domainObject"></param>
    public ValidationFailure Validate(object domainObject)
    {
        _domainObject = domainObject;

        return ValidateAgainstDomainObject();
    }

    /// <summary>
    /// Validate against the supplied domain object, which takes the form of a generic object with Properties matching TargetProperty or an SqlDataReader or a DataTable
    /// </summary>
    /// <param name="domainObject"></param>
    /// /// <param name="currentResults">It is expected that Validate is called multiple times (once per row) therefore you can store the Result of the last one and pass it back into the method the next time you call it in order to maintain a running total</param>
    /// <param name="worstConsequence"></param>
    public VerboseValidationResults ValidateVerboseAdditive(object domainObject,
        VerboseValidationResults currentResults, out Consequence? worstConsequence)
    {
        worstConsequence = null;

        _domainObject = domainObject;

        //first time initialize the results by calling its constructor (with all the ivs)
        currentResults ??= new VerboseValidationResults(ItemValidators.ToArray());

        var result = ValidateAgainstDomainObject();

        if (result != null)
            worstConsequence = currentResults.ProcessException(result);

        return currentResults;
    }


    /// <summary>
    /// Validate against the supplied domain object, which takes the form of a Dictionary.
    /// </summary>
    /// <param name="d"></param>
    public ValidationFailure Validate(Dictionary<string, object> d)
    {
        _domainObjectDictionary = d;

        return ValidateAgainstDictionary();
    }

    //This is static because creating new ones with the Type[] causes memory leaks in unmanaged memory   https://blogs.msdn.microsoft.com/tess/2006/02/15/net-memory-leak-xmlserializing-your-way-to-a-memory-leak/
    private static XmlSerializer _serializer;

    /// <summary>
    /// Instantiate a Validator from a (previously saved) XML string.
    /// </summary>
    /// <param name="xml"></param>
    /// <returns>a Validator</returns>
    public static Validator LoadFromXml(string xml)
    {
        if (string.IsNullOrWhiteSpace(xml))
            return null;

        InitializeSerializer();

        var rdr = XmlReader.Create(new StringReader(xml));
        return (Validator)_serializer.Deserialize(rdr);
    }

    private static void InitializeSerializer()
    {
        _serializer ??= new XmlSerializer(typeof(Validator), GetExtraTypes().ToArray());
    }

    /// <summary>
    /// Persist the current Validator instance to a string containing XML.
    /// </summary>
    /// <returns>a String</returns>
    public string SaveToXml(bool indent = true)
    {
        var sb = new StringBuilder();

        InitializeSerializer();

        using (var sw = XmlWriter.Create(sb, new XmlWriterSettings { Indent = indent }))
        {
            _serializer.Serialize(sw, this);
        }

        return sb.ToString();
    }

    private static readonly object _oLockExtraTypes = new();
    private static List<Type> _extraTypes;

    private static List<Type> RefreshExtraTypes()
    {
        lock (_oLockExtraTypes)
        {
            //var x = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a =>
            //{
            //    try
            //    {
            //        return a.GetTypes();
            //    }
            //    catch (Exception ex)
            //    {
            //        Console.WriteLine(ex.Message.ToString());
            //        System.Diagnostics.Debug.WriteLine(ex.Message);
            //        return null;
            //    }
            //}).Where(
            //        //type is
            //        type =>
            //            type != null &&
            //            //of the correct Type
            //            (typeof(IConstraint).IsAssignableFrom(type) ||
            //             typeof(PredictionRule).IsAssignableFrom(type)) //Constraint or prediction
            //            &&
            //            !type.IsAbstract
            //            &&
            //            !type.IsInterface
            //            &&
            //            type.IsClass
            //    ).ToList();
            return AppDomain.CurrentDomain.GetAssemblies().SelectMany(a =>
            {
                try
                {
                    return a.GetTypes();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    Console.WriteLine(a.FullName);
                    return null;
                }
            }).Where(
                    //type is
                    type =>
                        type != null &&
                        //of the correct Type
                        (typeof(IConstraint).IsAssignableFrom(type) ||
                         typeof(PredictionRule).IsAssignableFrom(type)) //Constraint or prediction
                        &&
                        !type.IsAbstract
                        &&
                        !type.IsInterface
                        &&
                        type.IsClass
                ).ToList();
            //return AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()).Where(
            //    //type is
            //    type =>
            //        type != null &&
            //        //of the correct Type
            //        (typeof(IConstraint).IsAssignableFrom(type) ||
            //         typeof(PredictionRule).IsAssignableFrom(type)) //Constraint or prediction
            //        &&
            //        !type.IsAbstract
            //        &&
            //        !type.IsInterface
            //        &&
            //        type.IsClass
            //).ToList();
        }
    }

    public static List<Type> GetExtraTypes()
    {
        lock (_oLockExtraTypes)
        {
            return _extraTypes ??= RefreshExtraTypes();
        }
    }


    /// <summary>
    /// This Factory method returns a new RegularExpression instance.
    /// </summary>
    /// <param name="pattern"></param>
    /// <returns></returns>
    public static ISecondaryConstraint CreateRegularExpression(string pattern) => new RegularExpression(pattern);

    /// <summary>
    /// Returns an array of available PrimaryConstraint names.
    /// Provides support for client applications who may need to display a list for selection.
    /// </summary>
    /// <returns></returns>
    public static string[] GetPrimaryConstraintNames()
    {
        var primaryConstraintTypes = FindSubClassesOf<PrimaryConstraint>();

        return primaryConstraintTypes.Select(t => t.Name.ToLower()).ToArray();
    }

    public static string[] GetSecondaryConstraintNames()
    {
        var secondaryConstraintTypes = FindSubClassesOf<SecondaryConstraint>().Where(t => t.IsAbstract == false);

        return secondaryConstraintTypes.Select(t => t.Name.ToLower()).ToArray();
    }

    /// <summary>
    /// This Factory method returns a Constraint corresponding to the supplied constraint name.
    /// The name must match the corresponding class name. Matching is case-insensitive.
    /// An ArgumentException is thrown if a matching constraint cannot be found.
    /// </summary>
    /// <param name="name"></param>
    /// <param name="consequence"></param>
    /// <returns>A Constraint</returns>
    public static IConstraint CreateConstraint(string name, Consequence consequence)
    {
        var type = GetExtraTypes().Single(t => t.Name.Equals(name, StringComparison.CurrentCultureIgnoreCase));
        var toReturn = (IConstraint)Activator.CreateInstance(type);
        toReturn.Consequence = consequence;
        return toReturn;
    }

    #region Fluent API experiment

    public ItemValidator ConstrainField(string fieldToValidate, Type type)
    {
        var i = new ItemValidator();
        AddItemValidator(i, fieldToValidate, type);

        return i;
    }

    public ItemValidator EnsureThatDate(string fieldToValidate)
    {
        var i = new ItemValidator();
        AddItemValidator(i, fieldToValidate, typeof(DateTime));

        return i;
    }

    public ItemValidator EnsureThatValue(string fieldToValidate)
    {
        var i = new ItemValidator();
        AddItemValidator(i, fieldToValidate, typeof(double));

        return i;
    }

    #endregion

    #region private methods

    private static IEnumerable<Type> FindSubClassesOf<TBaseType>()
    {
        return GetExtraTypes().Where(t => t.IsSubclassOf(typeof(TBaseType)));
    }

    private ValidationFailure ValidateAgainstDictionary()
    {
        var keys = new string[_domainObjectDictionary.Keys.Count];
        var vals = new object[_domainObjectDictionary.Values.Count];

        _domainObjectDictionary.Keys.CopyTo(keys, 0);
        _domainObjectDictionary.Values.CopyTo(vals, 0);


        var eList = new List<ValidationFailure>();

        //for all the columns we need to validate
        foreach (var itemValidator in ItemValidators)
            if (_domainObjectDictionary.TryGetValue(itemValidator.TargetProperty, out var o))
            {
                //get the first validation failure for the given column (or null if it is valid)
                var result = itemValidator.ValidateAll(o, vals, keys);

                //if it wasn't valid then add it to the eList
                if (result is { SourceItemValidator: null })
                {
                    result.SourceItemValidator = itemValidator;
                    eList.Add(result);
                }
            }
            else
            {
                throw new InvalidOperationException(
                    $"Validation failed: Target field [{itemValidator.TargetProperty}] not found in dictionary.");
            }

        return eList.Count > 0 ? new ValidationFailure("There are validation errors.", eList) : null;
    }

    private ValidationFailure ValidateAgainstDomainObject()
    {
        var eList = new List<ValidationFailure>();

        #region work out other column values

        string[] names = null;
        object[] values = null;

        var o = _domainObject;

        switch (o)
        {
            case DbDataReader reader:
                {
                    names = new string[reader.FieldCount];
                    values = new object[reader.FieldCount];

                    for (var i = 0; i < reader.FieldCount; i++)
                    {
                        names[i] = reader.GetName(i);
                        values[i] = reader[i] == DBNull.Value ? null : reader[i].ToString();
                    }

                    break;
                }
            case DataRow row:
                {
                    names = new string[row.Table.Columns.Count];
                    values = new object[row.Table.Columns.Count];

                    for (var i = 0; i < row.Table.Columns.Count; i++)
                    {
                        names[i] = row.Table.Columns[i].ColumnName;
                        values[i] = row[i] == DBNull.Value ? null : row[i].ToString();
                    }

                    break;
                }
        }

        #endregion


        foreach (var itemValidator in ItemValidators)
        {
            if (itemValidator.TargetProperty == null)
                throw new NullReferenceException("Target property cannot be null");

            try
            {
                ValidationFailure result;

                //see if it has property with this name
                object value;
                switch (o)
                {
                    case DbDataReader reader:
                        {
                            value = reader[itemValidator.TargetProperty];
                            if (value == DBNull.Value)
                                value = null;

                            result = itemValidator.ValidateAll(value, values, names);
                            break;
                        }
                    case DataRow row:
                        result = itemValidator.ValidateAll(row[itemValidator.TargetProperty], values, names);
                        break;
                    default:
                        {
                            var propertiesDictionary = DomainObjectPropertiesToDictionary(o);

                            if (!propertiesDictionary.TryGetValue(itemValidator.TargetProperty, out value))
                                throw new MissingFieldException(
                                    $"Validation failed: Target field [{itemValidator.TargetProperty}] not found in domain object.");

                            result = itemValidator.ValidateAll(value, propertiesDictionary.Values.ToArray(),
                                propertiesDictionary.Keys.ToArray());
                            break;
                        }
                }

                if (result != null)
                {
                    result.SourceItemValidator ??= itemValidator;
                    eList.Add(result);
                }
            }
            catch (IndexOutOfRangeException)
            {
                throw new IndexOutOfRangeException(
                    $"Validation failed: Target field [{itemValidator.TargetProperty}] not found in domain object.");
            }
        }

        return eList.Count > 0 ? new ValidationFailure("There are validation errors.", eList) : null;
    }

    private static Dictionary<string, object> DomainObjectPropertiesToDictionary(object o)
    {
        var toReturn = new Dictionary<string, object>();

        foreach (var prop in o.GetType().GetProperties())
            toReturn.Add(prop.Name, prop.GetValue(o));


        return toReturn;
    }

    #endregion

    public void RenameColumns(Dictionary<string, string> renameDictionary)
    {
        foreach (var kvp in renameDictionary)
            RenameColumn(kvp.Key, kvp.Value);
    }

    public void RenameColumn(string oldName, string newName)
    {
        foreach (var itemValidator in ItemValidators)
        {
            if (itemValidator.TargetProperty == oldName)
                itemValidator.TargetProperty = newName;

            itemValidator.PrimaryConstraint?.RenameColumn(oldName, newName);

            foreach (ISecondaryConstraint constraint in itemValidator.SecondaryConstraints)
                constraint.RenameColumn(oldName, newName);
        }
    }

    public static Type[] GetPredictionExtraTypes()
    {
        return GetExtraTypes().Where(static t => typeof(PredictionRule).IsAssignableFrom(t)).ToArray();
    }
}

1	// Copyright (c) The University of Dundee 2018-2019
2	// This file is part of the Research Data Management Platform (RDMP).
3	// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
4	// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
5	// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
6
7	using System;
8	using System.Collections.Generic;
9	using System.Data;
10	using System.Data.Common;
11	using System.IO;
12	using System.Linq;
13	using System.Text;
14	using System.Xml;
15	using System.Xml.Serialization;
16	using Rdmp.Core.Repositories;
17	using Rdmp.Core.Validation.Constraints;
18	using Rdmp.Core.Validation.Constraints.Primary;
19	using Rdmp.Core.Validation.Constraints.Secondary;
20	using Rdmp.Core.Validation.Constraints.Secondary.Predictor;
21
22	namespace Rdmp.Core.Validation;
23
24	/// <summary>
25	/// The Validator is the main entry point into this API. A client would typically create a Validator instance and then
26	/// add a number of ItemValidators to it. Alternatively you can use the static method LoadFromXml. Ensure you set
27	/// LocatorForXMLDeserialization.
28	///
29	/// <para>Generally, there are two phases of interaction with a Validator:</para>
30	///
31	/// <para>1. Design Time
32	/// During this phase, the client will instantiate and set up a Validator. The Check() method can be called to check for
33	/// any type incompatibilities prior to running the actual Validate() method.</para>
34	///
35	/// <para>2. Run Time
36	/// The Validation(o) method is called, applying the previously set up validation rules to the supplied domain object (o).</para>
37	///
38	/// <para>Note: As of this writing the Dictionary-based method is under active development, whereas the Object-based method
39	/// is not adequately developed or tested . PLEASE USE THE DICTIONARY method FOR NOW!</para>
40	/// </summary>
41	[XmlRoot("Validator")]
42	public class Validator
43	{
44	private object _domainObject;
45	private Dictionary<string, object> _domainObjectDictionary;
46
47	/// <summary>
48	/// Validation rules can reference objects e.g. StandardRegex. This static property indicates where to get the available instances available
49	/// for selection (the Catalogue database).
50	/// </summary>
51	public static ICatalogueRepositoryServiceLocator LocatorForXMLDeserialization;
52
53	public List<ItemValidator> ItemValidators { get; set; }	52,552✔
54
55
56	public Validator()	2,172✔
57	{
58	ItemValidators = new List<ItemValidator>();	2,172✔
59	}	2,172✔
60
61	/// <summary>
62	/// Adds an ItemValidator to the Validator, specifying the target property (in the object to be validated) and
63	/// the type that we expect this property to have. The type is used later in the Check() method. See below..
64	/// </summary>
65	/// <param name="itemValidator"></param>
66	/// <param name="targetProperty"></param>
67	/// <param name="expectedType"></param>
68	public void AddItemValidator(ItemValidator itemValidator, string targetProperty, Type expectedType)
69	{
70	if (ItemValidators.Any(iv => iv.TargetProperty.Equals(targetProperty)))	130✔
71	throw new ArgumentException(	2✔
72	"TargetProperty is already targeted by another ItemValidator in the collection");	2✔
73
74	itemValidator.TargetProperty = targetProperty;	120✔
75	itemValidator.ExpectedType = expectedType;	120✔
76
77	ItemValidators.Add(itemValidator);	120✔
78	}	120✔
79
80	/// <summary>
81	/// Returns the ItemValidator associated with the given key.
82	/// </summary>
83	/// <param name="key"></param>
84	/// <returns>An Itemvalidator reference, or null if no match found for the supplied key</returns>
85	public ItemValidator GetItemValidator(string key)
86	{
87	try
88	{
89	return ItemValidators.SingleOrDefault(iv => iv.TargetProperty.Equals(key));	2✔
90	}
91	catch (InvalidOperationException)	×
92	{
93	return null;	×
94	}
95	}	2✔
96
97	/// <summary>
98	/// Removes a given (key) ItemValidator from the collection.
99	/// </summary>
100	/// <param name="key"></param>
101	/// <returns>true if the removal succeeded, false otherwise</returns>
102	public bool RemoveItemValidator(string key)
103	{
104	ItemValidator toRemove;
105
106	try
107	{
108	toRemove = ItemValidators.First(iv => iv.TargetProperty.Equals(key));	2✔
109	}	×
110	catch (InvalidOperationException)	2✔
111	{
112	return false;	2✔
113	}
114
115
116	return ItemValidators.Remove(toRemove);	×
117	}	2✔
118
119	/// <summary>
120	/// Validate against the supplied domain object, which takes the form of a generic object.
121	/// </summary>
122	/// <param name="domainObject"></param>
123	public ValidationFailure Validate(object domainObject)
124	{
125	_domainObject = domainObject;	14✔
126
127	return ValidateAgainstDomainObject();	14✔
128	}
129
130	/// <summary>
131	/// Validate against the supplied domain object, which takes the form of a generic object with Properties matching TargetProperty or an SqlDataReader or a DataTable
132	/// </summary>
133	/// <param name="domainObject"></param>
134	/// /// <param name="currentResults">It is expected that Validate is called multiple times (once per row) therefore you can store the Result of the last one and pass it back into the method the next time you call it in order to maintain a running total</param>
135	/// <param name="worstConsequence"></param>
136	public VerboseValidationResults ValidateVerboseAdditive(object domainObject,
137	VerboseValidationResults currentResults, out Consequence? worstConsequence)
138	{
139	worstConsequence = null;	40,004✔
140
141	_domainObject = domainObject;	40,004✔
142
143	//first time initialize the results by calling its constructor (with all the ivs)
144	currentResults ??= new VerboseValidationResults(ItemValidators.ToArray());	40,004✔
145
146	var result = ValidateAgainstDomainObject();	40,004✔
147
148	if (result != null)	40,004✔
149	worstConsequence = currentResults.ProcessException(result);	1,381✔
150
151	return currentResults;	40,004✔
152	}
153
154
155	/// <summary>
156	/// Validate against the supplied domain object, which takes the form of a Dictionary.
157	/// </summary>
158	/// <param name="d"></param>
159	public ValidationFailure Validate(Dictionary<string, object> d)
160	{
161	_domainObjectDictionary = d;	96✔
162
163	return ValidateAgainstDictionary();	96✔
164	}
165
166	//This is static because creating new ones with the Type[] causes memory leaks in unmanaged memory https://blogs.msdn.microsoft.com/tess/2006/02/15/net-memory-leak-xmlserializing-your-way-to-a-memory-leak/
167	private static XmlSerializer _serializer;
168
169	/// <summary>
170	/// Instantiate a Validator from a (previously saved) XML string.
171	/// </summary>
172	/// <param name="xml"></param>
173	/// <returns>a Validator</returns>
174	public static Validator LoadFromXml(string xml)
175	{
176	if (string.IsNullOrWhiteSpace(xml))	2,044!
177	return null;	×
178
179	InitializeSerializer();	2,044✔
180
181	var rdr = XmlReader.Create(new StringReader(xml));	2,044✔
182	return (Validator)_serializer.Deserialize(rdr);	2,044✔
183	}
184
185	private static void InitializeSerializer()
186	{
187	_serializer ??= new XmlSerializer(typeof(Validator), GetExtraTypes().ToArray());	2,056✔
188	}	2,056✔
189
190	/// <summary>
191	/// Persist the current Validator instance to a string containing XML.
192	/// </summary>
193	/// <returns>a String</returns>
194	public string SaveToXml(bool indent = true)
195	{
196	var sb = new StringBuilder();	12✔
197
198	InitializeSerializer();	12✔
199
200	using (var sw = XmlWriter.Create(sb, new XmlWriterSettings { Indent = indent }))	12✔
201	{
202	_serializer.Serialize(sw, this);	12✔
203	}	12✔
204
205	return sb.ToString();	12✔
206	}
207
208	private static readonly object _oLockExtraTypes = new();	4✔
209	private static List<Type> _extraTypes;
210
211	private static List<Type> RefreshExtraTypes()
212	{
213	lock (_oLockExtraTypes)	4✔
214	{
215	//var x = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a =>
216	//{
217	// try
218	// {
219	// return a.GetTypes();
220	// }
221	// catch (Exception ex)
222	// {
223	// Console.WriteLine(ex.Message.ToString());
224	// System.Diagnostics.Debug.WriteLine(ex.Message);
225	// return null;
226	// }
227	//}).Where(
228	// //type is
229	// type =>
230	// type != null &&
231	// //of the correct Type
232	// (typeof(IConstraint).IsAssignableFrom(type) \|\|
233	// typeof(PredictionRule).IsAssignableFrom(type)) //Constraint or prediction
234	// &&
235	// !type.IsAbstract
236	// &&
237	// !type.IsInterface
238	// &&
239	// type.IsClass
240	// ).ToList();
241	return AppDomain.CurrentDomain.GetAssemblies().SelectMany(a =>	4✔
242	{	4✔
243	try	4✔
244	{	4✔
245	return a.GetTypes();	628✔
246	}	4✔
NEW 247	catch (Exception e)	×
248	{	4✔
NEW 249	Console.WriteLine(e.Message);	×
NEW 250	Console.WriteLine(a.FullName);	×
UNCOV 251	return null;	×
252	}	4✔
253	}).Where(	628✔
254	//type is	4✔
255	type =>	4✔
256	type != null &&	156,470✔
257	//of the correct Type	156,470✔
258	(typeof(IConstraint).IsAssignableFrom(type) \|\|	156,470✔
259	typeof(PredictionRule).IsAssignableFrom(type)) //Constraint or prediction	156,470✔
260	&&	156,470✔
261	!type.IsAbstract	156,470✔
262	&&	156,470✔
263	!type.IsInterface	156,470✔
264	&&	156,470✔
265	type.IsClass	156,470✔
266	).ToList();	4✔
267	//return AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()).Where(
268	// //type is
269	// type =>
270	// type != null &&
271	// //of the correct Type
272	// (typeof(IConstraint).IsAssignableFrom(type) \|\|
273	// typeof(PredictionRule).IsAssignableFrom(type)) //Constraint or prediction
274	// &&
275	// !type.IsAbstract
276	// &&
277	// !type.IsInterface
278	// &&
279	// type.IsClass
280	//).ToList();
281	}
282	}	4✔
283
284	public static List<Type> GetExtraTypes()
285	{
286	lock (_oLockExtraTypes)	240✔
287	{
288	return _extraTypes ??= RefreshExtraTypes();	240✔
289	}
290	}	240✔
291
292
293	/// <summary>
294	/// This Factory method returns a new RegularExpression instance.
295	/// </summary>
296	/// <param name="pattern"></param>
297	/// <returns></returns>
298	public static ISecondaryConstraint CreateRegularExpression(string pattern) => new RegularExpression(pattern);	10✔
299
300	/// <summary>
301	/// Returns an array of available PrimaryConstraint names.
302	/// Provides support for client applications who may need to display a list for selection.
303	/// </summary>
304	/// <returns></returns>
305	public static string[] GetPrimaryConstraintNames()
306	{
307	var primaryConstraintTypes = FindSubClassesOf<PrimaryConstraint>();	2✔
308
309	return primaryConstraintTypes.Select(t => t.Name.ToLower()).ToArray();	10✔
310	}
311
312	public static string[] GetSecondaryConstraintNames()
313	{
314	var secondaryConstraintTypes = FindSubClassesOf<SecondaryConstraint>().Where(t => t.IsAbstract == false);	16✔
315
316	return secondaryConstraintTypes.Select(t => t.Name.ToLower()).ToArray();	16✔
317	}
318
319	/// <summary>
320	/// This Factory method returns a Constraint corresponding to the supplied constraint name.
321	/// The name must match the corresponding class name. Matching is case-insensitive.
322	/// An ArgumentException is thrown if a matching constraint cannot be found.
323	/// </summary>
324	/// <param name="name"></param>
325	/// <param name="consequence"></param>
326	/// <returns>A Constraint</returns>
327	public static IConstraint CreateConstraint(string name, Consequence consequence)
328	{
329	var type = GetExtraTypes().Single(t => t.Name.Equals(name, StringComparison.CurrentCultureIgnoreCase));	3,480✔
330	var toReturn = (IConstraint)Activator.CreateInstance(type);	232✔
331	toReturn.Consequence = consequence;	232✔
332	return toReturn;	232✔
333	}
334
335	#region Fluent API experiment
336
337	public ItemValidator ConstrainField(string fieldToValidate, Type type)
338	{
339	var i = new ItemValidator();	×
340	AddItemValidator(i, fieldToValidate, type);	×
341
342	return i;	×
343	}
344
345	public ItemValidator EnsureThatDate(string fieldToValidate)
346	{
347	var i = new ItemValidator();	×
348	AddItemValidator(i, fieldToValidate, typeof(DateTime));	×
349
350	return i;	×
351	}
352
353	public ItemValidator EnsureThatValue(string fieldToValidate)
354	{
355	var i = new ItemValidator();	16✔
356	AddItemValidator(i, fieldToValidate, typeof(double));	16✔
357
358	return i;	16✔
359	}
360
361	#endregion
362
363	#region private methods
364
365	private static IEnumerable<Type> FindSubClassesOf<TBaseType>()
366	{
367	return GetExtraTypes().Where(t => t.IsSubclassOf(typeof(TBaseType)));	56✔
368	}
369
370	private ValidationFailure ValidateAgainstDictionary()
371	{
372	var keys = new string[_domainObjectDictionary.Keys.Count];	96✔
373	var vals = new object[_domainObjectDictionary.Values.Count];	96✔
374
375	_domainObjectDictionary.Keys.CopyTo(keys, 0);	96✔
376	_domainObjectDictionary.Values.CopyTo(vals, 0);	96✔
377
378
379	var eList = new List<ValidationFailure>();	96✔
380
381	//for all the columns we need to validate
382	foreach (var itemValidator in ItemValidators)	378✔
383	if (_domainObjectDictionary.TryGetValue(itemValidator.TargetProperty, out var o))	100✔
384	{
385	//get the first validation failure for the given column (or null if it is valid)
386	var result = itemValidator.ValidateAll(o, vals, keys);	98✔
387
388	//if it wasn't valid then add it to the eList
389	if (result is { SourceItemValidator: null })	86✔
390	{
391	result.SourceItemValidator = itemValidator;	46✔
392	eList.Add(result);	46✔
393	}
394	}
395	else
396	{
397	throw new InvalidOperationException(	2✔
398	$"Validation failed: Target field [{itemValidator.TargetProperty}] not found in dictionary.");	2✔
399	}
400
401	return eList.Count > 0 ? new ValidationFailure("There are validation errors.", eList) : null;	82✔
402	}
403
404	private ValidationFailure ValidateAgainstDomainObject()
405	{
406	var eList = new List<ValidationFailure>();	40,018✔
407
408	#region work out other column values
409
410	string[] names = null;	40,018✔
411	object[] values = null;	40,018✔
412
413	var o = _domainObject;	40,018✔
414
415	switch (o)
416	{
417	case DbDataReader reader:
418	{
419	names = new string[reader.FieldCount];	40,000✔
420	values = new object[reader.FieldCount];	40,000✔
421
422	for (var i = 0; i < reader.FieldCount; i++)	3,200,000✔
423	{
424	names[i] = reader.GetName(i);	1,560,000✔
425	values[i] = reader[i] == DBNull.Value ? null : reader[i].ToString();	1,560,000✔
426	}
427
428	break;	40,000✔
429	}
430	case DataRow row:
431	{
432	names = new string[row.Table.Columns.Count];	2✔
433	values = new object[row.Table.Columns.Count];	2✔
434
435	for (var i = 0; i < row.Table.Columns.Count; i++)	8✔
436	{
437	names[i] = row.Table.Columns[i].ColumnName;	2✔
438	values[i] = row[i] == DBNull.Value ? null : row[i].ToString();	2!
439	}
440
441	break;
442	}
443	}
444
445	#endregion
446
447
448	foreach (var itemValidator in ItemValidators)	240,068✔
449	{
450	if (itemValidator.TargetProperty == null)	80,018!
451	throw new NullReferenceException("Target property cannot be null");	✔
452
453	try
454	{
455	ValidationFailure result;
456
457	//see if it has property with this name
458	object value;
459	switch (o)
460	{
461	case DbDataReader reader:
462	{
463	value = reader[itemValidator.TargetProperty];	80,000✔
464	if (value == DBNull.Value)	80,000✔
465	value = null;	37,905✔
466
467	result = itemValidator.ValidateAll(value, values, names);	80,000✔
468	break;	80,000✔
469	}
470	case DataRow row:
471	result = itemValidator.ValidateAll(row[itemValidator.TargetProperty], values, names);	2✔
472	break;	2✔
473	default:
474	{
475	var propertiesDictionary = DomainObjectPropertiesToDictionary(o);	16✔
476
477	if (!propertiesDictionary.TryGetValue(itemValidator.TargetProperty, out value))	16✔
478	throw new MissingFieldException(	4✔
479	$"Validation failed: Target field [{itemValidator.TargetProperty}] not found in domain object.");	4✔
480
481	result = itemValidator.ValidateAll(value, propertiesDictionary.Values.ToArray(),	12✔
482	propertiesDictionary.Keys.ToArray());	12✔
483	break;
484	}
485	}
486
487	if (result != null)	80,014✔
488	{
489	result.SourceItemValidator ??= itemValidator;	1,383✔
490	eList.Add(result);	1,383✔
491	}
492	}	80,014✔
493	catch (IndexOutOfRangeException)	×
494	{
495	throw new IndexOutOfRangeException(	×
496	$"Validation failed: Target field [{itemValidator.TargetProperty}] not found in domain object.");	×
497	}
498	}
499
500	return eList.Count > 0 ? new ValidationFailure("There are validation errors.", eList) : null;	40,014✔
501	}
502
503	private static Dictionary<string, object> DomainObjectPropertiesToDictionary(object o)
504	{
505	var toReturn = new Dictionary<string, object>();	16✔
506
507	foreach (var prop in o.GetType().GetProperties())	72✔
508	toReturn.Add(prop.Name, prop.GetValue(o));	20✔
509
510
511	return toReturn;	16✔
512	}
513
514	#endregion
515
516	public void RenameColumns(Dictionary<string, string> renameDictionary)
517	{
518	foreach (var kvp in renameDictionary)	36✔
519	RenameColumn(kvp.Key, kvp.Value);	12✔
520	}	6✔
521
522	public void RenameColumn(string oldName, string newName)
523	{
524	foreach (var itemValidator in ItemValidators)	48✔
525	{
526	if (itemValidator.TargetProperty == oldName)	12✔
527	itemValidator.TargetProperty = newName;	2✔
528
529	itemValidator.PrimaryConstraint?.RenameColumn(oldName, newName);	12!
530
531	foreach (ISecondaryConstraint constraint in itemValidator.SecondaryConstraints)	48✔
532	constraint.RenameColumn(oldName, newName);	12✔
533	}
534	}	12✔
535
536	public static Type[] GetPredictionExtraTypes()
537	{
538	return GetExtraTypes().Where(static t => typeof(PredictionRule).IsAssignableFrom(t)).ToArray();	×
539	}
540	}

HicServices / RDMP / 11252482566

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous