chore: added new config option XmlCharEscaping

Will allow char escaping on Properties Value string

Author: GeorgeN-BET

ObjectSemantics.NET.Tests/ObjectSemanticsTests.cs

@@ -784,5 +784,53 @@ public void Should_Act_On_IfCondition_Having_Multiple_IF_Condition_Blocks_MultiL
             Assert.Equal(expectedResult, generatedTemplate, false, true, true);
         }
         #endregion
+
+
+        #region Xml Char Escape Tests
+        [Fact]
+        public void Should_Escape_Xml_Char_If_Option_Is_Enabled()
+        {
+            //Create Model
+            Student student = new Student { StudentName = "I've got \"special\" < & also >" };
+            var template = new ObjectSemanticsTemplate
+            {
+                FileContents = @"{{ StudentName }}"
+            };
+            string generatedTemplate = TemplateMapper.Map(student, template, null, new TemplateMapperOptions
+            {
+                XmlCharEscaping = true
+            });
+            string expectedString = "I&apos;ve got &quot;special&quot; &lt; &amp; also &gt;";
+            Assert.Equal(expectedString, generatedTemplate, false, true, true);
+        }
+
+
+        [Fact]
+        public void Should_Escape_Xml_Char_In_LOOPS_If_Option_Is_Enabled()
+        {
+            //Create Model
+            Student student = new Student
+            {
+                Invoices = new List<Invoice>
+                {
+                     new Invoice{  Narration="I've got \"special\""},
+                     new Invoice{  Narration="I've got  < & also >"}
+                }
+            };
+            //Template
+            var template = new ObjectSemanticsTemplate
+            {
+                FileContents = @"{{ #foreach(invoices)  }} [{{ Narration }}] {{ #endforeach }}"
+            };
+            string generatedTemplate = TemplateMapper.Map(student, template, null, new TemplateMapperOptions
+            {
+                XmlCharEscaping = true
+            });
+            string expectedResult = @" [I&apos;ve got &quot;special&quot;]  [I&apos;ve got &lt; &amp; also &gt;] ";
+            Assert.Equal(expectedResult, generatedTemplate, false, true, true);
+        }
+        #endregion
+
+
     }
 }

ObjectSemantics.NET/Algorithim/GavinsAlgorithim.cs

@@ -63,7 +63,7 @@ public static class GavinsAlgorithim
                     {
                         ExtractedObjProperty objProperty = rowRecordValues.FirstOrDefault(x => x.Name.ToUpper().Equals(objLoopCode.TargetPropertyName.ToUpper()));
                         if (objProperty != null)
-                            activeRow = activeRow.ReplaceFirstOccurrence(objLoopCode.ReplaceRef, objProperty.GetValueFromPropertyFormatted(objLoopCode.FormattingCommand));
+                            activeRow = activeRow.ReplaceFirstOccurrence(objLoopCode.ReplaceRef, objProperty.GetPropertyDisplayString(objLoopCode.FormattingCommand, options));
                         else
                             activeRow = activeRow.ReplaceFirstOccurrence(objLoopCode.ReplaceRef, objLoopCode.ReplaceCommand);
                     }
@@ -85,7 +85,7 @@ public static class GavinsAlgorithim
         {
             ExtractedObjProperty property = objProperties.FirstOrDefault(x => x.Name.ToUpper().Equals(replaceCode.TargetPropertyName.ToUpper()));
             if (property != null)
-                clonedTemplate.Template = clonedTemplate.Template.ReplaceFirstOccurrence(replaceCode.ReplaceRef, property.GetValueFromPropertyFormatted(replaceCode.FormattingCommand));
+                clonedTemplate.Template = clonedTemplate.Template.ReplaceFirstOccurrence(replaceCode.ReplaceRef, property.GetPropertyDisplayString(replaceCode.FormattingCommand, options));
             else
                 clonedTemplate.Template = clonedTemplate.Template.ReplaceFirstOccurrence(replaceCode.ReplaceRef, @"{{ ##command## }}".Replace("##command##", replaceCode.ReplaceCommand));
         }

ObjectSemantics.NET/Extensions/ExtractedObjPropertyExtensions.cs

@@ -1,11 +1,22 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security;
+
 namespace ObjectSemantics.NET
 {
     public static class ExtractedObjPropertyExtensions
     {
-        public static string GetValueFromPropertyFormatted(this ExtractedObjProperty p, string customFormattingValue)
+        public static string GetPropertyDisplayString(this ExtractedObjProperty p, string stringFormatting, TemplateMapperOptions templateMapperOptions)
+        {
+            string formattedPropertyString = GetAppliedPropertyFormatting(p, stringFormatting);
+            //Apply Options to Property value string
+            if (templateMapperOptions==null) return formattedPropertyString;
+            if (templateMapperOptions.XmlCharEscaping)
+                formattedPropertyString = SecurityElement.Escape(formattedPropertyString);
+            return formattedPropertyString;
+        }
+        private static string GetAppliedPropertyFormatting(this ExtractedObjProperty p, string customFormattingValue)
         {
             if (string.IsNullOrWhiteSpace(customFormattingValue))
                 return p.StringFormatted;

ObjectSemantics.NET/TemplateMapperOptions.cs

@@ -2,6 +2,15 @@
 {
     public class TemplateMapperOptions
     {
-
+        /// <summary>
+        /// This will  apply XML Character Escape on invalid characters in a Property Value String with their valid XML Equivalent
+        /// Example of Characters;
+        /// " &quot;
+        /// ' &apos;
+        /// < &lt;
+        /// > &gt;
+        /// & &amp;
+        /// </summary>
+        public bool XmlCharEscaping { get; set; } = false;
     }
 }