fix typos, add json property names

- fix JsonPropertyName for relationships in dom
- fix equals type on Cardinality
- clean code documentation snippets
- add missing [JsonPropertyName] for some attributes
-

Author: sjohansson

DataWarehouseAutomation/DataWarehouseAutomation/DwaModel/Cardinality.cs

@@ -17,19 +17,21 @@ public class Cardinality
     /// <summary>
     /// Optional information to name a certain cardinality construct.
     /// For example one-to-one, one-to-many, or many-to-many.
-    /// E.g. one-to-one could be defined as {"from": {"min": 1, "max": 1}, "to": {"min": 1, "max": 1}}.
+    /// E.g. one-to-one could be defined as {"fromRange": {"min": "1", "max": "1"}, "toRange": {"min": "1", "max": "1"}}.
     /// </summary>
     [JsonPropertyName("name")]
     public string? Name { get; set; }
 
     /// <summary>
     /// The 'from' component in the cardinality, e.g. the '1' in 1 to many.
     /// </summary>
+    [JsonPropertyName("fromRange")]
     public CardinalityRange? FromRange { get; set; } = new CardinalityRange { Min = "1", Max = "1" };
 
     /// <summary>
     /// The 'to' component in the cardinality, e.g. the 'many' in 1 to many.
     /// </summary>
+    [JsonPropertyName("toRange")]
     public CardinalityRange? ToRange { get; set; } = new CardinalityRange { Min = "1", Max = "N" };
 
     /// <summary>
@@ -55,13 +57,13 @@ public class Cardinality
 
     #region Methods
     /// <summary>
-    /// Use this method to assert if two Data Connections are the same, based on their Ids.
+    /// Use this method to assert if two Cardinalities are the same, based on their Ids.
     /// </summary>
     /// <param name="obj"></param>
-    /// <returns>True if the Data Connections are the same, based on their Ids</returns>
+    /// <returns>True if the Cardinalities are the same, based on their Ids</returns>
     public override bool Equals(object? obj)
     {
-        var other = obj as DataConnection;
+        var other = obj as Cardinality;
         return other?.Id == Id;
     }
 
@@ -72,8 +74,8 @@ public override bool Equals(object? obj)
     public override int GetHashCode() => (Id?.GetHashCode()) ?? 0;
 
     /// <summary>
-    /// String override so that the object returns its value ('connection string').
-    /// When an instance of this class is passed to a method that expects a string, the ToString() method will be called implicitly to convert the object to a string, and the value of the "Connection String" property will be returned.
+    /// String override so that the object returns its value ('Name').
+    /// When an instance of this class is passed to a method that expects a string, the ToString() method will be called implicitly to convert the object to a string, and the value of the "Name" property will be returned.
     /// </summary>
     /// <returns>The Name</returns>
     public override string ToString()

DataWarehouseAutomation/DataWarehouseAutomation/DwaModel/CardinalityRange.cs

@@ -2,11 +2,14 @@
 
 /// <summary>
 /// The possible range for a from/to component for the cardinality.
-/// For eaxmple "min": 1, "max": "N"
-/// This way, you can define at least 1 to many. Or 0 or 1 to 1.
+/// For example "min": "1", "max": "N"
+/// This way, you can define "at least 1 to many". Or "0 or 1 to 1".
 /// </summary>
 public class CardinalityRange
 {
+    [JsonPropertyName("min")]
     public string? Min { get; set; }
+
+    [JsonPropertyName("max")]
     public string? Max { get; set; }
 }

DataWarehouseAutomation/DataWarehouseAutomation/DwaModel/DataObjectMapping.cs

@@ -3,15 +3,18 @@
 namespace DataWarehouseAutomation.DwaModel;
 
 /// <summary>
-/// The mapping between a source and target data set / table / file.
-/// 
+/// <para>The mapping between a source and target data set / table / file.</para>
+/// <para>
 /// The DataObjectMapping is the element that defines an individual source-to-target mapping / ETL process. It is a mapping between a source and target object - referred to as DataObjects.
-/// The DataObject is in fact a reusable definition in the Json schema.
-///
-/// This definition is used twice in the DataObjectMapping: as the *SourceDataObject* and as the *TargetDataObject* - both instances of the DataObject class / type.
-///
-/// The other key component of a DataObjectMapping is the* DataItemMapping*, which describes the column-to-column(or transformation-to-column).
+/// The DataObject <see cref="IDataObject"/> is in fact a reusable definition in the Json schema.
+/// </para>
+/// <para>This definition is used twice in the DataObjectMapping: as the *SourceDataObjects* and as the *TargetDataObject*
+/// - both instances/lists of <see cref="IDataObject"/>,
+/// implemented as <see cref="DataObject"/> or <see cref="DataObjectQuery"/>.</para>
+/// <para>
+/// The other key component of a DataObjectMapping is the <see cref="DataItemMapping"/> *DataItemMapping*, which describes the column-to-column (or transformation-to-column).
 /// The SourceDataObject, TargetDataObject and DataItemMapping are the mandatory components of a DataObjectMapping.There are many other attributes that can be set, and there are mandatory items within the DataObjects and DataItems.These are all described in the Json schema.
+/// </para>
 /// </summary>
 public class DataObjectMapping : IMetadata
 {
@@ -54,7 +57,7 @@ public class DataObjectMapping : IMetadata
     /// The collection of associated data object for purposes other than source-target relationship.
     /// For example for lookups, merge joins, lineage etc.
     /// </summary>
-    [JsonPropertyName("relatedDataObjects")]
+    [JsonPropertyName("relationships")]
     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
     public List<Relationships>? Relationships { get; set; }
 

DataWarehouseAutomation/DataWarehouseAutomation/DwaModel/DataObjectMappingList.cs

@@ -1,12 +1,15 @@
 namespace DataWarehouseAutomation.DwaModel;
 
 /// <summary>
+/// <para>
 /// The schema's top-level object is a 'DataObjectMappingList'. It is an array of individual source-to-target mappings called 'DataObjectMappings', commonly referred to as 'mappings'.
-/// In code, this means a DataObjectMappingList is defined as a List/<DataObjectMapping/>.
-/// 
+/// In code, this means a DataObjectMappingList is defined as a List of <see cref="DataObjectMapping"/>.
+/// </para>
+/// <para>
 /// A DataObjectMapping is a unique ETL mapping / transformation that moves, or interprets, data from a given source to a given destination.
-/// The decision to start the format with an array / list that contains potentially multiple DataObjectMappings relates to the Data Warehouse virtualization use-case. In these implementations, multiple individual mappings together create a single view object. 
-/// As an example, consider the loading of a Core Business Concept / Hub type entity from various different sources.If you would use these different mappings to generate ETL processes you would create one physical ETL object for each mapping. However, if you are seeking to generate a view that represents the target table the result you would use the collection (list) of mappings to generate separate statements that are unioned in the single view object.
+/// The decision to start the format with an array / list that contains potentially multiple DataObjectMappings relates to the Data Warehouse virtualization use-case. In these implementations, multiple individual mappings together create a single view object.
+/// As an example, consider the loading of a Core Business Concept / Hub type entity from various different sources. If you would use these different mappings to generate ETL processes you would create one physical ETL object for each mapping. However, if you are seeking to generate a view that represents the target table the result you would use the collection (list) of mappings to generate separate statements that are unioned in the single view object.
+/// </para>
 /// </summary>
 public class DataObjectMappingList
 {