Completed update for Migration Adapter Pattern

Author: jhannahLCD

src/WebFormsToBlazorServerCommands/Migration/AspxToBlazorControlConverter.cs

@@ -1,9 +1,16 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.NetworkInformation;
 using System.ServiceModel.Configuration;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using AngleSharp;
+using AngleSharp.Dom;
+using AngleSharp.Html.Parser;
+using CodeFactory.Formatting.CSharp;
+using NLog.Targets.Wrappers;
 
 namespace WebFormsToBlazorServerCommands.Migration
 {
@@ -12,9 +19,12 @@ namespace WebFormsToBlazorServerCommands.Migration
     /// </summary>
     public class AspxToBlazorControlConverter : ControlConverterBase
     {
-        public AspxToBlazorControlConverter(ITagControlConverter adapterHost):base(adapterHost) 
+        private static AngleSharp.IConfiguration _angleSharpConfig = AngleSharp.Configuration.Default;
+        private static AngleSharp.IBrowsingContext _angleSharpContext = null; 
+
+        public AspxToBlazorControlConverter(ITagControlConverter adapterHost) : base(adapterHost)
         {
-           _TagsICanConvert = new List<string>();
+            _TagsICanConvert = new List<string>();
 
             _TagsICanConvert.Add("asp:listview");
             _TagsICanConvert.Add("asp:content");
@@ -39,9 +49,182 @@ public AspxToBlazorControlConverter(ITagControlConverter adapterHost):base(adapt
             _TagsICanConvert.Add("asp:datalist");
             _TagsICanConvert.Add("asp:datagrid");
             _TagsICanConvert.Add("asp:dropdownlist");
-                        
+
+            _angleSharpContext = BrowsingContext.New(_angleSharpConfig);
+        }
+
+        /// <summary>
+        /// Class specific override of the baseclass ControlConverterBase
+        /// </summary>
+        /// <param name="tagName"></param>
+        /// <param name="tagNodeContent"></param>
+        /// <returns></returns>
+        public override async Task<string> ConvertControlTag(string tagName, string tagNodeContent)
+        {
+            string _result = string.Empty;
+
+            switch (tagName.ToLowerInvariant())
+            {
+                case "asp:content":
+                    _result = await ConvertContentControl(tagNodeContent);
+                    break;
+
+                case "asp:formview":
+                    _result = await ConvertFormViewControl(tagNodeContent);
+                    break;
+
+                case "asp:editform":
+                    _result = await ConvertEditFormControl(tagNodeContent);
+                    break;
+
+                default:
+                    _result = await ConvertGenericControl(tagNodeContent);
+                    break;
+            }
+
+            return _result;
+
+        }
+
+        #region Private conversion methods
+
+        /// <summary>
+        /// This method is used to generically convert an asp control by removing the 'asp:' 
+        /// prefix from the control name and then returning the resultant content back to the caller.
+        /// </summary>
+        /// <param name="nodeContent"></param>
+        /// <returns>converted control content</returns>
+        private async Task<string> ConvertGenericControl(string nodeContent)
+        {
+
+            try
+            {
+                int pos = nodeContent.IndexOf("asp:");
+                if (pos < 0)
+                {
+                    return nodeContent;
+                }
+
+                return nodeContent.Substring(0, pos) + "" + nodeContent.Substring(pos + "asp:".Length);
+            }
+            catch (Exception ex)
+            {
+
+                throw ex;
+            }
+        }
+
+        /// <summary>
+        /// This method understands now to convert an asp:FormView control into a blazor equivalent.
+        /// </summary>
+        /// <param name="nodeContent"></param>
+        /// <returns></returns>
+        private async Task<string> ConvertFormViewControl(string nodeContent)
+        {
+            var model = await _angleSharpContext.OpenAsync(req => req.Content(nodeContent));
+            var parser = new HtmlParser();
+
+            try
+            {
+
+                var editFormNode = model.All.Where(p => p.LocalName.ToLower().Equals("asp:formview")).FirstOrDefault();
+                var newNode = parser.ParseFragment($"<EditForm Model={editFormNode.GetAttribute("ItemType")} OnValidSubmit={editFormNode.GetAttribute("SelectMethod")}></EditForm>", editFormNode);
+
+                //this is now a live list having substituted the EditForm control for the old FormView one
+                newNode.First().AppendNodes(editFormNode.ChildNodes.ToArray());
+
+                if (model.All.Any(p => p.TagName.ToLower().Equals("itemtemplate")))
+                {
+                    //deal with itemtemplates... ??
+                }
+
+                //send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
+                var aspFormTags = newNode.First().Descendents<IElement>().Where(p => p.NodeName.ToLower().Contains("asp:")).ToList();
+                foreach (var formObj in aspFormTags)
+                {
+                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.NodeName, formObj.OuterHtml);
+
+                    var tempNode = parser.ParseFragment(migratedControlText, null);
+
+                    //ParseFragment always adds on a HTML & BODY tags, at least with this call setup.  We need to pull out *just* the element that we have migrated.
+                    var appendElement = tempNode.GetElementsByTagName("BODY").First().ChildNodes;
+
+                    formObj.Replace(appendElement.ToArray());
+                }
+
+                return newNode.First().ToHtml();//.OuterHTML; // .ToString();
+            }
+            catch (Exception ex)
+            {
+
+                throw ex;
+            }
         }
 
+        /// <summary>
+        /// This method understands how to convert an asp:EditForm control into a blazor equivalent.
+        /// </summary>
+        /// <param name="nodeContent"></param>
+        /// <returns></returns>
+        private async Task<string> ConvertEditFormControl(string nodeContent)
+        {
+            string _result = string.Empty;
+
+            try
+            {
+                //return content as-is for now.
+                return nodeContent;
+            }
+            catch (Exception ex)
+            {
+
+                throw ex;
+            }
+        }
 
+        /// <summary>
+        /// This method is used to convert the asp:Content control to a Blazor equivalent.  In this particular 
+        /// case - there is no equivalent.  This control is the top-level asp:* container for a page and really just holds all other
+        /// controls that are found in an *.aspx page definition.
+        /// </summary>
+        /// <param name="nodeContent"></param>
+        /// <returns></returns>
+        private async Task<string> ConvertContentControl(string nodeContent)
+        {
+            string _result = string.Empty;
+            var parser = new HtmlParser();
+
+            try
+            {
+                var model = await _angleSharpContext.OpenAsync(req => req.Content(nodeContent));
+
+                var contentControlObj = model.Descendents<Element>().First(c => c.TagName.ToLower().Equals("asp:content"));
+
+                //send any child asp:* controls to be converted by the a call back out to the adapterHosting class.
+                var aspFormTags = contentControlObj.Descendents<IElement>().Where(p => p.NodeName.ToLower().Contains("asp:")).ToList();
+                foreach (var formObj in aspFormTags)
+                {
+                    var migratedControlText = await _adapterHost.MigrateTagControl(formObj.NodeName, formObj.OuterHtml);
+
+                    var tempNode = parser.ParseFragment(migratedControlText, null);
+
+                    //ParseFragment always adds on a HTML & BODY tags, at least with this call setup.  We need to pull out *just* the element that we have migrated.
+                    var appendElement = tempNode.GetElementsByTagName("BODY").First().ChildNodes;
+
+                    formObj.Replace(appendElement.ToArray());
+                }
+
+                //There isn't any asp:content control equivalent in Blazor, so we'll just take the innerHTML
+                _result = contentControlObj.InnerHtml;
+
+                return _result;
+            }
+            catch (Exception ex)
+            {
+
+                throw ex;
+            }
+        }
+        #endregion
     }
 }

src/WebFormsToBlazorServerCommands/Migration/ControlConverterBase.cs

@@ -12,7 +12,7 @@ namespace WebFormsToBlazorServerCommands.Migration
     /// </summary>
     public class ControlConverterBase : IControlConverter
     {
-        private ITagControlConverter _adapterHost = null;
+        internal ITagControlConverter _adapterHost = null;
         internal List<string> _TagsICanConvert = null;
 
         public ControlConverterBase(ITagControlConverter adapterHost)
@@ -37,13 +37,13 @@ public ReadOnlyCollection<string> AvailableConversionTags
         /// <param name="tagName"></param>
         /// <param name="tagNodeContent"></param>
         /// <returns></returns>
-        public string ConvertControlTag(string tagName, string tagNodeContent)
+        public virtual async Task<string> ConvertControlTag(string tagName, string tagNodeContent)
         {
             StringBuilder _result = new StringBuilder();
 
             try
             {
-
+                _result.Append(tagNodeContent);
 
                 return _result.ToString();
             }

src/WebFormsToBlazorServerCommands/Migration/ConverterAdapter.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using System.Windows.Documents;
 
 namespace WebFormsToBlazorServerCommands.Migration
@@ -12,40 +13,61 @@ public class ConverterAdapter : ITagControlConverter
         private string _returnResult = string.Empty;
         private List<IControlConverter> _controlConverters = null;
 
-        public ConverterAdapter(List<IControlConverter> controlTagConverters)
+        public ConverterAdapter()
         {
-            _controlConverters = controlTagConverters;
         }
 
+        public bool RegisterControlConverter(IControlConverter converterObj)
+        {
+            try
+            {
+                if (_controlConverters == null)
+                {
+                    _controlConverters = new List<IControlConverter>();
+                }
+                _controlConverters.Add(converterObj);
+
+                return true;
+            }
+            catch (System.Exception)
+            {
+
+                return false;
+            }
+
+        }
+
+
         /// <summary>
         /// This method takes an incoming tag/control and its inclusive text represention and returns the converted text.
         /// </summary>
         /// <param name="tagControlName"></param>
         /// <param name="tagNodeContent"></param>
         /// <returns>The converted text - otherwise a String.Empty if there is no converter registered for the passed in tagControlName</returns>
-        public string MigrateTagControl(string tagControlName, string tagNodeContent)
+        public async Task<string> MigrateTagControl(string tagControlName, string tagNodeContent)
         {
             string _returnResult = string.Empty;
 
             try
             {
                 if (string.IsNullOrEmpty(tagControlName) )
                 {
-                    return 
+                    return "nothing to convert.";
                 }
 
                 //iterate over all of the IControlConverters that have been registerd and find the 
                 //*first* one that knows how to convert the passed in tag
 
                 //check if control is available to be converted from IControlConverter
-                if (!_tagConverter.AvailableConversionTags.Contains(tagControlName))
+                foreach (var registerdConverter in _controlConverters)
                 {
-                    return tagNodeContent;
+                    if (registerdConverter.AvailableConversionTags.Contains(tagControlName.ToLower()))
+                    {
+                        //Call migration logic from specific class
+                        _returnResult = await registerdConverter.ConvertControlTag(tagControlName, tagNodeContent);
+                    }
                 }
 
-                //Call migration logic from specific class
-                _returnResult = _tagConverter.ConvertControlTag(tagControlName, tagNodeContent);
-
                 return _returnResult;
             }
             catch (System.Exception)

src/WebFormsToBlazorServerCommands/Migration/IControlConverter.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Threading.Tasks;
 
 namespace WebFormsToBlazorServerCommands.Migration
 {
@@ -18,5 +19,6 @@ public interface IControlConverter
         /// </summary>
         /// <param name="tagName"></param>
         /// <param name="tagNodeContent"></param>
-        string ConvertControlTag(string tagName, string tagNodeContent)
+        Task<string> ConvertControlTag(string tagName, string tagNodeContent);
+    }
 }

src/WebFormsToBlazorServerCommands/Migration/ITagControlConverter.cs

@@ -14,7 +14,7 @@ public interface ITagControlConverter
         /// <param name="tagControlName"></param>
         /// <param name="tagNodeContent"></param>
         /// <returns>The converted/migrated string content of the TagControl.  It is entirely possible that the return NodeText will have overridded the TagControlName into something else entirely.  ie.  a Blazor control</returns>
-        string MigrateTagControl(string tagControlName, string tagNodeContent);
+        Task<string> MigrateTagControl(string tagControlName, string tagNodeContent);
 
     }
 }