RuleUri.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="RuleUri.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Parses a rule:// URI to provide</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
 
namespace Csla.Rules
{
  public class RuleUri
  {
    private Uri _uri;
 
    public RuleUri(string ruleString)
      : this(new Uri(ruleString))
    { }
 
    public RuleUri(Uri uri)
    {
      _uri = uri;
      if (_uri.Scheme != "rule")
        throw new ArgumentException("RuleUri.Scheme");
    }
 
    public RuleUri(IBusinessRuleBase rule, Csla.Core.IPropertyInfo property)
      : this(GetTypeName(rule), ((property == null) ? "(object)" : property.Name))
      //: this(rule.GetType().FullName, ((property == null) ? "null" : property.Name))
    { }
 
    public RuleUri(string typeName, string propertyName)
    {
      var hostName = EncodeString(typeName).Replace(".-", ".");
      if (hostName.Length > 63)
      {
        var tmp = hostName;
        hostName = null;
        for (int i = 0; i < tmp.Length - 1; i = i + 63)
          hostName = hostName + tmp.Substring(i, ((i + 63 <= tmp.Length) ? 63 : tmp.Length - i)) + "/";
        hostName = hostName.Substring(0, hostName.Length - 1);
      }
 
      var uriString = "rule://" + hostName + "/" + EncodeString(propertyName);
      _uri = new Uri(uriString);
    }
 
    private static string EncodeString(string value)
    {
      var result = value;
      result = result.Replace("+", "-");
      result = result.Replace(" ", "");
      result = result.Replace("[", "");
      result = result.Replace("]", "");
      result = result.Replace("`", "-");
      result = result.Replace(",", "-");
      result = result.Replace("=", "-");
      result = Uri.EscapeDataString(result);
      result = result.Replace("%", "-");
      return result;
    }
 
    public static RuleUri Parse(string ruleString)
    {
      return new RuleUri(ruleString);
    }
 
    public override string ToString()
    {
      return _uri.ToString();
    }
 
    public void AddQueryParameter(string key, string value)
    {
      var uriText = ToString();
      if (uriText.Contains("?"))
        uriText = uriText + "&" + Uri.EscapeDataString(key) + "=" + Uri.EscapeDataString(value);
      else
        uriText = uriText + "?" + Uri.EscapeDataString(key) + "=" + Uri.EscapeDataString(value);
      _uri = new Uri(uriText);
    }
 
    public string RuleTypeName
    {
      get 
      {
        string name = _uri.Host;
        if (_uri.Parts().Length > 1)
          for (int i = 0; i < _uri.Parts().Length - 1; i++)
            name = name + _uri.Parts()[i];
        return name.Replace("/", "");
      }
    }
 
    public string PropertyName
    {
      get { return _uri.Parts()[_uri.Parts().Length - 1]; }
    }
 
    public Dictionary<string, string> Arguments
    {
      get
      {
        Dictionary<string, string> result = null;
        string args = _uri.Query;
        if (!(string.IsNullOrEmpty(args)))
        {
          if (args.StartsWith("?"))
            args = args.Remove(0, 1);
 
          result = new Dictionary<string, string>();
          string[] argArray = args.Split('&');
          foreach (string arg in argArray)
          {
            string[] argParams = arg.Split('=');
            result.Add(
              System.Uri.UnescapeDataString(argParams[0]),
              System.Uri.UnescapeDataString(argParams[1]));
          }
        }
        return result;
      }
    }
 
    private static string GetTypeName(IBusinessRuleBase rule)
    {
      var type = rule.GetType();
      return GetTypeName(type);
    }
 
    private static string GetTypeName(Type type)
    {
      if (!type.IsGenericType)
      {
        return type.FullName;
      }
      else // generic type
      {
        var sb = new StringBuilder();
        if (!string.IsNullOrEmpty(type.Namespace)) 
          sb.Append(type.Namespace + ".");
        var typeName = type.Name;
        sb.Append(typeName.Replace("`1", ""));
        foreach (var t in type.GetGenericArguments())
        {
          sb.Append("-");
          if (t.IsGenericType) 
            sb.Append(GetTypeName(t));
          else 
            sb.Append(t.FullName);
          sb.Append("-");
        }
        return sb.ToString();
      }
    }
  }
 
  public static class UriExtensions
  {
    public static string[] Parts(this System.Uri uri)
    {
      return uri.Segments;
    }
  }
 
}