//******************************************************************************************************//  WebExtensions.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may not use this//  file except in compliance with the License. You may obtain a copy of the License at:////      http://opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  02/17/2016 - J. Ritchie Carroll//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Generic;using System.Dynamic;using System.IO;using System.Linq;using System.Net;using System.Net.Http;using System.Net.Http.Headers;using System.Reflection;using System.Threading.Tasks;using System.Web;using System.Web.Mvc;using GSF.Collections;using GSF.IO;using GSF.Web.Model;using RazorEngine.Templating;using HtmlHelper = System.Web.Mvc.HtmlHelper; namespace GSF.Web{    /// <summary>    /// Defines extension methods useful for web applications.    /// </summary>    public static class WebExtensions    {        // Nested Types         // Defines a multi-part stream provider that will parse out files and form data        private class PostDataStreamProvider : MultipartStreamProvider        {            #region [ Members ]             // Fields            private readonly PostData m_postData;            private readonly List<bool> m_isFormData;             #endregion             #region [ Constructors ]             public PostDataStreamProvider()            {                m_postData = new PostData();                m_isFormData = new List<bool>();            }             #endregion             #region [ Properties ]             // Gets any data passed as part of the multi-part form data            public PostData PostData => m_postData;             #endregion             #region [ Methods ]             // Gets the stream where to write the body part to. This method is called when a MIME multi-part body part has been parsed            public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)            {                // For form data, Content-Disposition header is a requirement                ContentDispositionHeaderValue contentDisposition = headers.ContentDisposition;                 if ((object)contentDisposition == null)                    throw new InvalidOperationException("Expected \"Content-Disposition\" header field not found in MIME multi-part body.");                 // Post process this body part as form data if no file name is specified                m_isFormData.Add(string.IsNullOrEmpty(contentDisposition.FileName));                 return new MemoryStream();            }             // Executes the post processing operation reading the non-file contents as form data            public override async Task ExecutePostProcessingAsync()            {                for (int i = 0; i < Contents.Count; i++)                {                    if (m_isFormData[i])                    {                        HttpContent formContent = Contents[i];                        ContentDispositionHeaderValue contentDisposition = formContent.Headers.ContentDisposition;                        string fieldName = UnquoteToken(contentDisposition.Name) ?? "";                         // Read out any form data                        string fieldValue = await formContent.ReadAsStringAsync();                        m_postData.FormData.Add(fieldName, fieldValue);                    }                    else                    {                        m_postData.FileData.Add(Contents[i]);                    }                }            }             #endregion             #region [ Static ]             // Static Methods            private static string UnquoteToken(string token)            {                if (string.IsNullOrWhiteSpace(token))                    return token;                 if (token.StartsWith("\"", StringComparison.Ordinal) && token.EndsWith("\"", StringComparison.Ordinal) && token.Length > 1)                    return token.Substring(1, token.Length - 2);                 return token;            }             #endregion        }         // Defines a GetMemberBinder implementation to get DynamicViewBag properties by name        private class MemberBinder : GetMemberBinder        {            public MemberBinder(string name) : base(name, false)            {            }             public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion) => null;        }          // Static Fields        private static readonly HashSet<string> s_executingAssemblyResources;        private static readonly HashSet<string> s_callingAssemblyResources;        private static readonly HashSet<string> s_entryAssemblyResources;         // Static Constructor        static WebExtensions()        {            s_executingAssemblyResources = new HashSet<string>(Assembly.GetExecutingAssembly().GetManifestResourceNames(), StringComparer.Ordinal);            s_callingAssemblyResources = new HashSet<string>(Assembly.GetCallingAssembly().GetManifestResourceNames(), StringComparer.Ordinal);            s_entryAssemblyResources = new HashSet<string>(Assembly.GetEntryAssembly()?.GetManifestResourceNames() ?? new[] { "" }, StringComparer.Ordinal);        }         // Static Methods         /// <summary>        /// Performs JavaScript encoding on given string.        /// </summary>        /// <param name="text">The string to be encoded.</param>        public static string JavaScriptEncode(this string text)        {            return HttpUtility.JavaScriptStringEncode(text.ToNonNullString());        }         /// <summary>        /// Performs HTML encoding on the given string.        /// </summary>        /// <param name="text">The string to be encoded.</param>        public static string HtmlEncode(this string text)        {            return HttpUtility.HtmlEncode(text.ToNonNullString());        }         /// <summary>        /// Performs URL encoding on the given string.        /// </summary>        /// <param name="text">The string to be encoded.</param>        public static string UrlEncode(this string text)        {            return HttpUtility.UrlEncode(text.ToNonNullString());        }         /// <summary>        /// Corrects script alignment with a desired number of forward spaces.        /// </summary>        /// <param name="script">Script text.</param>        /// <param name="spaces">Desired forward spaces.</param>        /// <returns>Script with corrected forward alignment.</returns>        public static string FixForwardSpacing(this string script, int spaces = 4)        {            Tuple<string, int>[] linesAndLengths = script                .Split(new[] { Environment.NewLine }, StringSplitOptions.None)                .Select(line => new Tuple<string, int>(line, line.Length - line.TrimStart(' ').Length))                .ToArray();             int minLength = linesAndLengths                .Select(lineAndLength => (int?)lineAndLength.Item2)                .Where(length => length.GetValueOrDefault() > 0)                .Min() ?? 0;             string forwardSpacing = new string(' ', spaces);             return linesAndLengths                .Select(lineAndLength => lineAndLength.Item2 > 0 ?                    $"{forwardSpacing}{(lineAndLength.Item2 > minLength ? lineAndLength.Item1.Substring(minLength) : lineAndLength.Item1)}" :                    lineAndLength.Item1.ToNonNullNorEmptyString())                .ToDelimitedString(Environment.NewLine);        }         /// <summary>        /// Gets query parameters for current request message        /// </summary>        /// <param name="request"></param>        /// <returns></returns>        public static Dictionary<string, string> QueryParameters(this HttpRequestMessage request)        {            return request.GetQueryNameValuePairs().ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase);        }         /// <summary>        /// Gets a collection of uploaded post data from an <see cref="HttpRequestMessage"/>.        /// </summary>        /// <param name="request"><see cref="HttpRequestMessage"/> request data that contains form data and/or uploaded files.</param>        /// <returns>Parsed post data.</returns>        public static PostData GetPostData(this HttpRequestMessage request)        {            // Providing non-async version to simplify processing within Razor script            Task<PostData> getPostDataTask = GetPostDataAsync(request);             getPostDataTask.ContinueWith(task =>            {                if ((object)task.Exception != null)                    throw task.Exception;            },            TaskContinuationOptions.OnlyOnFaulted);             return getPostDataTask.Result;        }         /// <summary>        /// Asynchronously gets a collection of uploaded post data from an <see cref="HttpRequestMessage"/>.        /// </summary>        /// <param name="request"><see cref="HttpRequestMessage"/> request data that contains form data and/or uploaded files.</param>        /// <returns>Parsed post data.</returns>        public static async Task<PostData> GetPostDataAsync(this HttpRequestMessage request)        {            PostDataStreamProvider provider = await request.Content.ReadAsMultipartAsync(new PostDataStreamProvider());            return provider.PostData;        }         /// <summary>        /// Converts relative URL to an absolute URL.        /// </summary>        /// <param name="helper">MVC HTML helper instance.</param>        /// <param name="url">Relative URL.</param>        /// <returns>Absolute URL.</returns>        public static string ToAbsoluteUrl(this HtmlHelper helper, string url)        {            if (string.IsNullOrEmpty(url))                return "";             if (HttpContext.Current == null)                return "";             if (url.StartsWith("/"))                url = url.Insert(0, "~");             if (!url.StartsWith("~/"))                url = url.Insert(0, "~/");             Uri uri = HttpContext.Current.Request.Url;            string port = uri.Port == 80 ? "" : ":" + uri.Port;             return $"{uri.Scheme}://{uri.Host}{port}{VirtualPathUtility.ToAbsolute(url)}";        }         /// <summary>        /// Includes an HTTP resource directly into an MVC view page.        /// </summary>        /// <param name="helper">MVC HTML helper instance.</param>        /// <param name="url">URL of resource to include.</param>        /// <returns>Resolved URL resource as an MvcHtmlString.</returns>        public static MvcHtmlString IncludeUrl(this HtmlHelper helper, string url)        {            if (string.IsNullOrEmpty(url))                return new MvcHtmlString("");             HttpWebRequest request = WebRequest.CreateHttp(url);            request.Credentials = CredentialCache.DefaultCredentials;             using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)            using (Stream stream = response?.GetResponseStream())            {                if ((object)stream == null)                    return new MvcHtmlString($"<!-- No response from {url} -->");                 using (StreamReader reader = new StreamReader(stream))                    return new MvcHtmlString(reader.ReadToEnd());            }        }         /// <summary>        /// Includes an embedded resource directly into an MVC view page.        /// </summary>        /// <param name="helper">MVC HTML helper instance.</param>        /// <param name="resourceName">Resource to include.</param>        /// <returns>Resource as an MvcHtmlString.</returns>        public static MvcHtmlString IncludeResouce(this HtmlHelper helper, string resourceName)        {            if (string.IsNullOrEmpty(resourceName))                return new MvcHtmlString("");             Stream stream = OpenEmbeddedResourceStream(resourceName);             if ((object)stream == null)                return new MvcHtmlString("");             using (StreamReader reader = new StreamReader(stream))                return new MvcHtmlString(reader.ReadToEnd());        }         /// <summary>        /// Renders a Razor view from an embedded resource.        /// </summary>        /// <param name="helper">MVC HTML helper instance.</param>        /// <param name="resourceName">Embedded resource name.</param>        /// <param name="modelType">Type of model.</param>        /// <param name="model">Model instance.</param>        /// <returns>Rendered resource as an MvcHtmlString.</returns>        /// <remarks>        /// If needed by view, define ViewBag.DataContext before rendering resource.        /// </remarks>        public static MvcHtmlString RenderResource(this HtmlHelper helper, string resourceName, Type modelType = null, object model = null)        {            MvcHtmlString result;            DynamicViewBag viewBag = new DynamicViewBag(helper.ViewData);            bool isPost = HttpContext.Current.Request.HttpMethod.Equals("POST", StringComparison.OrdinalIgnoreCase);             viewBag.AddValue("IsPost", isPost);            viewBag.AddValue("Request", HttpContext.Current.Items["MS_HttpRequestMessage"] ?? new HttpRequestMessage(isPost ? HttpMethod.Post : HttpMethod.Get, HttpContext.Current.Request.Url));                       if (FilePath.GetExtension(resourceName).Equals(".vbhtml", StringComparison.OrdinalIgnoreCase))                result = new MvcHtmlString(RazorEngine<VisualBasicEmbeddedResource>.Default.RunCompile(resourceName, modelType, model, viewBag));            else                result = new MvcHtmlString(RazorEngine<CSharpEmbeddedResource>.Default.RunCompile(resourceName, modelType, model, viewBag));             // Copy any new or updated view bag elements back to MVC view data dictionary            foreach (string memberName in viewBag.GetDynamicMemberNames())            {                object value;                 viewBag.TryGetMember(new MemberBinder(memberName), out value);                 if (value != null)                    helper.ViewData[memberName] = value;            }             return result;        }         /// <summary>        /// Renders a Razor view from an embedded resource.        /// </summary>        /// <typeparam name="T">Type of model.</typeparam>        /// <param name="helper">MVC HTML helper instance.</param>        /// <param name="resourceName">Embedded resource name.</param>        /// <param name="model">Model instance.</param>        /// <returns>Rendered resource as an MvcHtmlString.</returns>        /// <remarks>        /// If needed by view, define ViewBag.DataContext before rendering resource.        /// </remarks>        public static MvcHtmlString RenderResource<T>(this HtmlHelper helper, string resourceName, T model)        {            return RenderResource(helper, resourceName, typeof(T), model);        }         /// <summary>        /// Determines if specified embedded resource exists.        /// </summary>        /// <param name="resourceName">Fully qualified name of resource to check.</param>        /// <returns><c>true</c> if resource exists; otherwise, <c>false</c>.</returns>        public static bool EmbeddedResourceExists(string resourceName)        {            return                s_executingAssemblyResources.Contains(resourceName) ||                s_callingAssemblyResources.Contains(resourceName) ||                s_entryAssemblyResources.Contains(resourceName);        }         /// <summary>        /// Opens a stream to an embedded resource.        /// </summary>        /// <param name="resourceName">Fully qualified name of resource to open.</param>        /// <returns>Stream to embedded resource if found; otherwise, <c>null</c>.</returns>        public static Stream OpenEmbeddedResourceStream(string resourceName)        {            if (s_executingAssemblyResources.Contains(resourceName))                return Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);             if (s_callingAssemblyResources.Contains(resourceName))                return Assembly.GetCallingAssembly().GetManifestResourceStream(resourceName);             if (s_entryAssemblyResources.Contains(resourceName))                return Assembly.GetEntryAssembly().GetManifestResourceStream(resourceName);             return null;        }    }}