ZelWiki/ZelWiki.Library/QueryStringConverter.cs

using Microsoft.AspNetCore.Http;
using System.Text;
using System.Web;
using ZelWiki.Library.Interfaces;

namespace ZelWiki.Library
{
    public static class QueryStringConverter
    {
        /// <summary>
        /// 排序
        /// </summary>
        /// <param name="context"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string OrderHelper(ISessionState context, string value)
        {
            var orderByKey = "OrderBy";
            var orderByDirectionKey = "OrderByDirection";
            var currentDirection = "asc";
            var collection = ToDictionary(context.QueryString);

            
            if (collection.TryGetValue(orderByKey, out var currentValue))
            {
                bool invertDirection = string.Equals(currentValue, value, StringComparison.InvariantCultureIgnoreCase);

                if (invertDirection)
                {
                    if (collection.TryGetValue(orderByDirectionKey, out currentDirection))
                    {
                        currentDirection = currentDirection == "asc" ? "desc" : "asc";
                    }
                }
                else
                {
                    currentDirection = "asc";
                }
            }

            collection.Remove(orderByKey);
            collection.Add(orderByKey, value);

            collection.Remove(orderByDirectionKey);
            collection.Add(orderByDirectionKey, currentDirection ?? "asc");

            return FromCollection(collection);
        }

/// <summary>
/// 
/// </summary>
/// <param name="queryString"></param>
/// <param name="name"></param>
/// <param name="value"></param>
/// <returns></returns>
        public static string Upsert(IQueryCollection? queryString, string name, string value)
        {
            var collection = ToDictionary(queryString);
            collection.Remove(name);
            collection.Add(name, value);
            return FromCollection(collection);
        }

        public static Dictionary<string, string> ToDictionary(IQueryCollection? queryString)
        {
            if (queryString == null)
            {
                return new Dictionary<string, string>();
            }

            var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

            foreach (var item in queryString)
            {
                dictionary.Add(item.Key, item.Value.Single() ?? string.Empty);
            }

            return dictionary;
        }

        public static Dictionary<string, string> ToDictionary(QueryString? queryString)
            => ToDictionary(queryString?.ToString());

        public static Dictionary<string, string> ToDictionary(string? queryString)
        {
            var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            if (string.IsNullOrEmpty(queryString))
            {
                return dictionary;
            }

            if (queryString.StartsWith('?'))
            {
                queryString = queryString.Substring(1);
            }

            var keyValuePairs = queryString.Split('&');

            foreach (var kvp in keyValuePairs)
            {
                var keyValue = kvp.Split('=');
                if (keyValue.Length == 2)
                {
                    var key = HttpUtility.UrlDecode(keyValue[0]);
                    var value = HttpUtility.UrlDecode(keyValue[1]);
                    dictionary[key] = value;
                }
            }

            return dictionary;
        }

        public static string FromCollection(IQueryCollection? collection)
        {
            if (collection == null || collection.Count == 0)
            {
                return string.Empty;
            }

            var queryString = new StringBuilder();

            foreach (var kvp in collection)
            {
                if (queryString.Length > 0)
                {
                    queryString.Append('&');
                }

                queryString.Append($"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value.ToString())}");
            }

            return queryString.ToString();
        }

        public static string FromCollection(Dictionary<string, string>? collection)
        {
            if (collection == null || collection.Count == 0)
            {
                return string.Empty;
            }

            var queryString = new StringBuilder();

            foreach (var kvp in collection)
            {
                if (queryString.Length > 0)
                {
                    queryString.Append('&');
                }

                queryString.Append($"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}");
            }

            return queryString.ToString();
        }

        public static Dictionary<string, string> Clone(Dictionary<string, string>? original)
        {
            if (original == null)
            {
                return new Dictionary<string, string>();
            }

            var clone = new Dictionary<string, string>(original.Count, original.Comparer);
            foreach (var kvp in original)
            {
                clone.Add(kvp.Key, kvp.Value);
            }

            return clone;
        }
    }
}