md review

sjohansson · sjohansson · commit 7fd2e0bccfa1 · 2024-04-27T13:13:40.000+10:00
minor clean, tangential to the work on the other docs sites
diff --git a/docs/build.bat b/docs/build.bat
@@ -0,0 +1,13 @@
+@echo off
+
+REM Make sure we're running this from the context of the script file location
+pushd %~dp0
+
+REM Build through docfx, using the docfx.json configuration file
+REM This will generate the static site in the _site folder
+REM note that docfx needs to be installed and available in the PATH
+
+REM Install docfx: dotnet tool install -g docfx
+REM Docos: https://dotnet.github.io/docfx/tutorial/docfx_getting_started.html
+
+docfx docfx.json
diff --git a/docs/faq/index.md b/docs/faq/index.md
@@ -2,7 +2,7 @@
 
 ## Why have a schema definition for Data Warehouse Automation?
 
-The reason work on the schema definition started is based on a desire to collaborate with various likeminded professionals in the industry, but who all had different (proprietary) ways to record metadata. The challenge was how to collaborate on at least the patterns, without necessarily agreeing on ‘the best’ back-end solution to store metadata.
+The reason work on the schema definition started is based on a desire to collaborate with various like-minded professionals in the industry, but who all had different (proprietary) ways to record metadata. The challenge was how to collaborate on at least the patterns, without necessarily agreeing on ‘the best’ back-end solution to store metadata.
 
 The interface for Data Warehouse Automation was started as an initiative that would support each to use the back-end of their choosing, while still be able to cooperate on the design and improvement of Data Warehouse implementation patterns and ETL generation concepts.
 
@@ -16,11 +16,11 @@ The decision to start the format with an array / list that contains potentially
 
 For example, consider the loading of a Core Business Concept (‘Hub’) type entity from various different data 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 you would use the collection (list) of mappings to generate separate statements that are 'unioned' in a single view object.
 
-Example: [https://github.com/RoelantVos/Data-Warehouse-Automation-Metadata-Schema/blob/master/ClassLibrary/DataWarehouseAutomation/Sample_Metadata/sampleBasic.json].
+Example: [https://github.com/RoelantVos/Data-Warehouse-Automation-Metadata-Schema/blob/master/ClassLibrary/DataWarehouseAutomation/Sample_Metadata/sampleBasic.json](https://github.com/RoelantVos/Data-Warehouse-Automation-Metadata-Schema/blob/master/ClassLibrary/DataWarehouseAutomation/Sample_Metadata/sampleBasic.json).
 
 Or below, an even more simplified example of a single Data Object Mapping (with only one source, one target and a single Data Item Mapping) being part of the list dataObjectMappings.
 
-````json
+```json
 {
   "dataObjectMappings": [
     {
@@ -48,7 +48,7 @@ Or below, an even more simplified example of a single Data Object Mapping (with
     }
   ]
 }
-`````
+```
 
 ## Why are Data Objects and Data Items defined as arrays when they are used as sources?
 
@@ -58,7 +58,7 @@ The downside is that either a loop or array index needs to be used to pinpoint t
 
 Example: using Handlebars will give you the name of the first source object:
 
-```JSON
+```handlebars
 {{sourceDataObjects.0.name}}
 ```
 
@@ -76,7 +76,7 @@ The easiest way to get started is to either copy and modify the example project,
 
 A simple C# example to generate some quick ETL (taken from the example project):
 
-```json
+```cs
 // Load a template (pattern) from file
 stringTemplate = File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + @"..\\..\\TemplateSampleBasic.handlebars");
 
@@ -94,4 +94,4 @@ result = template(deserialisedMapping);
 
 // Display the results to the user
 Console.WriteLine(result);
-``````
+```
diff --git a/docs/handlebars/extension_exists.md b/docs/handlebars/extension_exists.md
@@ -8,21 +8,21 @@ Only the *multiActiveKey* and *targetDataItem* properties are currently supporte
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{#exists "<category / json segment>" "<optional value>"}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 {{#exists multiActiveKey}}There is a multi-active key!{{else}}No multi-active key is found in this data object mapping.{{/exists}}
 {{#exists multiActiveKey "DATE_OF_BIRTH"}}There is a multi-active key which is not DATE_OF_BIRTH{{else}}No multi-active key with DATE_OF_BIRTH is found in this data object mapping.{{/exists}}
 {{#exists targetDataItem}}There is a target data item in this mapping!{{else}}No target data items are defined in this mapping.{{/exists}}
 ```
 
 Depending on the metadata, this may result in:
 
-```dotnetcli
+```text
 There is a multi-active key!
 No multi-active key with DATE_OF_BIRTH is found in this data object mapping.
 There is a target data item in this mapping!
diff --git a/docs/handlebars/extension_lookupextension.md b/docs/handlebars/extension_lookupextension.md
@@ -8,18 +8,18 @@ Pass in the extensions list and the string key value.
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{lookupExtension <extension list> "<string value>"}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 The lookup value for the 'type' extension is '{{lookupExtension sourceDataObjects.0.extensions "type"}}'.
 ```
 
 Depending on the metadata, this may result in:
 
-```dotnetcli
+```text
 The lookup value for the 'type' extension is 'procedure'.
 ```
diff --git a/docs/handlebars/extension_now.md b/docs/handlebars/extension_now.md
@@ -4,13 +4,13 @@ Get the date and time at the moment of execution.
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{now}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 The time is {{now}}.
 ```
 
diff --git a/docs/handlebars/extension_randomdate.md b/docs/handlebars/extension_randomdate.md
@@ -6,18 +6,18 @@ This was originally added to generate test data, and is used for referential-int
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{randomdate 2020}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 Here is a random date: {{randomdate 2020}}.
 ```
 
 This may return:
 
-```dotnetcli
+```text
 2022-08-03T00:00:00.000000
 ```
diff --git a/docs/handlebars/extension_randomnumber.md b/docs/handlebars/extension_randomnumber.md
@@ -6,18 +6,18 @@ This was originally added to generate test data, and is used for referential-int
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{randomnumber 5}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 And here is a random string: {{randomnumber 5}}.
 ```
 
 This may return:
 
-```dotnetcli
+```text
 1346
 ```
diff --git a/docs/handlebars/extension_randomstring.md b/docs/handlebars/extension_randomstring.md
@@ -4,18 +4,18 @@ Generate a random string no longer than the provided characters as integer input
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{randomstring 10}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 And here is a random string: {{randomstring 10}}.
 ```
 
 This returns:
 
-```dotnetcli
+```text
 Cg8uKuBFS5
 ```
diff --git a/docs/handlebars/extension_replicate.md b/docs/handlebars/extension_replicate.md
@@ -6,21 +6,21 @@ This is often used to generate test data.
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{#replicate 10}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 {{#replicate 3}}
 This value is replicated 3 times!
 {{/replicate}}
 ```
 
 This returns:
 
-```dotnetcli
+```text
 This value is replicated 3 times!
 This value is replicated 3 times!
 This value is replicated 3 times!
diff --git a/docs/handlebars/extension_space.md b/docs/handlebars/extension_space.md
@@ -4,18 +4,18 @@ Space will space out (!?) the name of the input value to 30 characters using tab
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{space "<value>"}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 This is {{space "Hello World"}} ...spaced out.
 ```
 
 This results in:
 
-```dotnetcli
+```text
 This is Hello World                                              ...spaced out.
 ```
diff --git a/docs/handlebars/extension_stringcompare.md b/docs/handlebars/extension_stringcompare.md
@@ -4,18 +4,18 @@ Block helper to evaluate if the input matches a specified string. Also optionall
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{#stringcompare string1 string2}} do something {{else}} do something else {{/stringcompare}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 A and B {{#stringcompare "A" "B"}}are the same. {{else}}are not the same. {{/stringcompare}}
 ```
 
 This results in:
 
-```dotnetcli
+```text
 A and B are not the same.
 ```
diff --git a/docs/handlebars/extension_stringdiff.md b/docs/handlebars/extension_stringdiff.md
@@ -4,18 +4,18 @@ Block helper to evaluate if the input does *not* match a specified string. Also
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{#stringdiff string1 string2}} do something {{else}} do something else {{/stringdiff}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 A and B {{#stringdiff "A" "B"}}are not the same. {{else}}are the same. {{/stringdiff}}
 ```
 
 This results in:
 
-```dotnetcli
+```text
 A and B are not the same.
 ```
diff --git a/docs/handlebars/extension_stringreplace.md b/docs/handlebars/extension_stringreplace.md
@@ -4,18 +4,18 @@ Parses an input string value, and replaces a specified part of the contents with
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{stringreplace "<input string value>" "<lookup character>" "<replacement character>"}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 This replaces the o's in Hello Word with an !: {{StringReplace "Hello World" "o" "!"}}
 ```
 
 This results in:
 
-```dotnetcli
+```text
 This replaces the o's in Hello Word with an !: Hell! W!rld
 ```
diff --git a/docs/handlebars/extension_stringwrap.md b/docs/handlebars/extension_stringwrap.md
@@ -4,18 +4,18 @@ Wraps an input character string with two specified characters.
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{stringwrap "<start character>" "<end character>"}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 This adds brackets around the string value: {{stringwrap "Example" "[" "]"}}
 ```
 
 This results in:
 
-```dotnetcli
+```text
 [Example]
 ```
diff --git a/docs/handlebars/extension_targetdataitemexists.md b/docs/handlebars/extension_targetdataitemexists.md
@@ -8,18 +8,18 @@ This is used in some cases to handle special column names.
 
 ## Usage
 
-``` handlebars
+```handlebars
 {{stringwrap "<character value>"}}
 ```
 
 ## Example
 
-``` handlebars
+```handlebars
 {{#targetDataItemExists "FIRST_NAME"}}FIRST_NAME exists{{else}}FIRST_NAME does not exist{{/targetDataItemExists}}
 ```
 
 This results in:
 
-```dotnetcli
+```text
 FIRST_NAME exists
 ```
diff --git a/docs/index.md b/docs/index.md
@@ -38,4 +38,4 @@ Across most, if not all, metadata models there is a core set of information that
 
 ### Working guidelines
 
-For any change, create a new branch (no direct commits to master branch).
+For any change, create a new branch (no direct commits to main branch).
diff --git a/docs/overview/Index.md b/docs/overview/Index.md
@@ -13,15 +13,15 @@ The schema definition can be directly viewed [here](https://github.com/RoelantVo
 * A sample implementation that generates code using [Handlebars.Net](http://roelantvos.com/blog/using-handlebars-to-generate-data-vault-hub-load-processes/). The example that uses the Handlebars generates code using a sample JSON file that conforms to the interface schema.
 * A simple regression test application that demonstrates different usages of the schema.
 
-The schema is and examples are validated / extended using <https://www.jsonschemavalidator.net/>. Standards are followed from [json-schema.org](http://json-schema.org/).  Also see [some miscellaneous examples](http://json-schema.org/learn/miscellaneous-examples.html).
+The schema is and examples are validated / extended using [https://www.jsonschemavalidator.net/](https://www.jsonschemavalidator.net/). Standards are followed from [json-schema.org](http://json-schema.org/).  Also see [some miscellaneous examples](http://json-schema.org/learn/miscellaneous-examples.html).
 
 In principle, the schema can be used to generate an entire Data Warehouse, Data Lake and equivalent and/or similar.
 
 ## **Schema**
 
 The JSON schema for data solution automation has standard components for table (DataObjects) and column (DataItem) structures that are reused for sources and targets. At the mapping level only the classification, filter and load direction are added, the rest is generic reuse of definitions.
 
-The schema is available in the GitHub under:  https://github.com/RoelantVos/Data_Warehouse_Automation_Metadata_Interface.
+The schema is available in the GitHub under:  [https://github.com/RoelantVos/Data_Warehouse_Automation_Metadata_Interface](https://github.com/RoelantVos/Data_Warehouse_Automation_Metadata_Interface).
 
 The schema definition itself is located here: [https://github.com/data-solution-automation-engine/data-warehouse-automation-metadata-schema/blob/main/GenericInterface/interfaceDataWarehouseAutomationMetadataV2_0.json](https://github.com/data-solution-automation-engine/data-warehouse-automation-metadata-schema/blob/main/GenericInterface/interfaceDataWarehouseAutomationMetadataV2_0.json).
 
@@ -35,8 +35,8 @@ The Data Object Mapping is literally a mapping between Data Objects. It is a uni
 
 At a high level there are two elements that form the core of a Data Object Mapping, these are the:
 
-- Data Object, which defines the source and target of the Data Object Mapping. A Data Object can optionally have a connection defined as a string or token, and can be a query, file or table.
-- Data Item, which belong to a Data Object and represents an individual column or calculation (query) in a Data Object Mapping.
+* Data Object, which defines the source and target of the Data Object Mapping. A Data Object can optionally have a connection defined as a string or token, and can be a query, file or table.
+* Data Item, which belong to a Data Object and represents an individual column or calculation (query) in a Data Object Mapping.
 
 ![img](http://roelantvos.com/blog/wp-content/uploads/2020/01/DataObject-3-1024x466.png)
 
@@ -62,7 +62,7 @@ By combining this, the Data Object Mapping looks as follows at a high level:
 
 At the top level, one or more Data Object Mappings are grouped into a single Data Object Mapping List. The convention is that, even though only a single Data Object Mapping may be needed in a message or file, a Data Object Mapping is *always* part of a Data Object Mapping List.
 
-In other words, the Data Object Mapping List is an array of individual Data Object Mappings. In code, this means a Data Object Mapping List is defined as a List<DataObjectMapping>.
+In other words, the Data Object Mapping List is an array of individual Data Object Mappings. In code, this means a Data Object Mapping List is defined as a `List<DataObjectMapping>`.
 
 The decision to start the format with an array / list that contains potentially multiple Data Object Mappings relates to the Data Warehouse virtualisation use-case. In this style of implementation, multiple individual mappings together create a single view object. Testing revealed it is much harder to piece the relationships between mappings together at a later stage to create a single (view) object, and having the option to define a collection makes this really easy.
 
diff --git a/docs/overview/getting-started.md b/docs/overview/getting-started.md
diff --git a/docs/serve.bat b/docs/serve.bat
