/// <summary>
/// @param urlPart The part you want the index of
/// @return Returns the index of the part
/// </summary>
public int IndexOf(UrlPart urlPart)
{
switch (urlPart)
{
case UrlPart.SCHEME:
return(_schemeIndex);
case UrlPart.USERNAME_PASSWORD:
return(_usernamePasswordIndex);
case UrlPart.HOST:
return(_hostIndex);
case UrlPart.PORT:
return(_portIndex);
case UrlPart.PATH:
return(_pathIndex);
case UrlPart.QUERY:
return(_queryIndex);
case UrlPart.FRAGMENT:
return(_fragmentIndex);
default:
return(-1);
}
}
public MethodInfoNode(AbstractNode parent, MethodInfo mi)
{
Parent = parent;
UrlPart = new UrlPart(mi.Name);
Title = mi.Name;
MethodInfo = mi;
}
public void SetIndex(UrlPart urlPart, int index)
{
switch (urlPart)
{
case UrlPart.SCHEME:
_schemeIndex = index;
break;
case UrlPart.USERNAME_PASSWORD:
_usernamePasswordIndex = index;
break;
case UrlPart.HOST:
_hostIndex = index;
break;
case UrlPart.PORT:
_portIndex = index;
break;
case UrlPart.PATH:
_pathIndex = index;
break;
case UrlPart.QUERY:
_queryIndex = index;
break;
case UrlPart.FRAGMENT:
_fragmentIndex = index;
break;
}
}
public static UrlPart?GetNextPart(this UrlPart currentPart)
{
switch (currentPart)
{
case UrlPart.FRAGMENT:
return(null);
case UrlPart.QUERY:
return(UrlPart.FRAGMENT);
case UrlPart.PATH:
return(UrlPart.QUERY);
case UrlPart.PORT:
return(UrlPart.PATH);
case UrlPart.HOST:
return(UrlPart.PORT);
case UrlPart.USERNAME_PASSWORD:
return(UrlPart.HOST);
case UrlPart.SCHEME:
return(UrlPart.USERNAME_PASSWORD);
default:
throw new ArgumentException($"Unexpected current UrlPart: {currentPart}");
}
}
/// <summary>
/// 获取url字符串的各部分
/// </summary>
/// <param name="url"></param>
/// <param name="urlPart"></param>
/// <returns></returns>
public static string GetUrlPart(string url, UrlPart urlPart)
{
string result = string.Empty;
Regex reg = new Regex(@"^((?<protocol>\w+)://)?(?<hostname>[^/:]+):?(?<port>\d+)?", RegexOptions.Compiled | RegexOptions.IgnoreCase);
switch (urlPart)
{
case UrlPart.PROTOCOL:
result = reg.Match(url).Result("${protocol}");
if (string.IsNullOrEmpty(result))
{
result = "http";
}
break;
case UrlPart.PORT:
result = reg.Match(url).Result("${port}");
if (string.IsNullOrEmpty(result))
{
result = "80";
}
break;
case UrlPart.HOST_NAME:
result = reg.Match(url).Result("${hostname}");
break;
}
return(result);
}
public ChildNode GetChild(UrlPart part)
{
ChildNode child = default(ChildNode);
if (Items.TryGetValue(part, out child))
{
return(child);
}
return(null);
}
/// <summary>
/// Get the Raw value of a specific part of the Url, before an decoding was done.
/// </summary>
/// <param name="part"></param>
/// <returns></returns>
public string GetRaw(UrlPart part)
{
string result = string.Empty;
switch (part)
{
case UrlPart.Scheme:
result = this._scheme;
break;
case UrlPart.User:
result = this._user;
break;
case UrlPart.Password:
result = this._password;
break;
case UrlPart.Host:
result = this._host;
break;
case UrlPart.Port:
result = this._port.ToString();
break;
case UrlPart.PortExplicit:
result = this._portRaw;
break;
case UrlPart.Path:
result = this._path;
break;
case UrlPart.Query:
result = this._query;
break;
case UrlPart.Fragment:
result = this._fragment;
break;
default:
break;
}
return(result);
}
protected internal Node(AbstractNode parent, UrlPart urlPart, string title, Term terms) : this(title, terms)
{
if (parent == null)
{
throw new ArgumentException();
}
var childNodes = (parent as IHasChildNodes)?.ChildNodes ?? ChildNodes.Empty;
if (urlPart == null || childNodes.HasChild(urlPart))
{
throw new ArgumentException();
}
this.Parent = parent;
this.UrlPart = urlPart;
}
/// <summary>
/// For example, in http://yahoo.com/lala/, nextExistingPart(UrlPart.HOST) would return UrlPart.PATH
/// @param urlPart The current url part
/// @return Returns the next part; if there is no existing next part, it returns null
/// </summary>
/// <param name="urlPart"></param>
/// <returns></returns>
private UrlPart?NextExistingPart(UrlPart urlPart)
{
var nextPart = urlPart.GetNextPart();
if (Exists(nextPart))
{
return(nextPart);
}
if (nextPart == null)
{
return(null);
}
return(NextExistingPart(nextPart.Value));
}
/// <summary>
/// @param part The part that we want. Ex: host, path
/// </summary>
/// <param name="part"></param>
/// <returns></returns>
private string GetPart(UrlPart part)
{
if (!Exists(part))
{
return(null);
}
var nextPart = NextExistingPart(part);
if (nextPart == null)
{
return(_originalUrl.Substring(_urlMarker.IndexOf(part)));
}
var beginIndex = _urlMarker.IndexOf(part);
var endIndex = _urlMarker.IndexOf(nextPart.Value);
return(_originalUrl.Substring(beginIndex, endIndex - beginIndex));
}
/// <summary>
/// Get the value from debug mode
/// </summary>
/// <param name="url">input browser url</param>
/// <param name="value">the value from UrlPart</param>
/// <returns>Locale,PageID,FamilyVersion,HostName</returns>
public static string UrlParts(string url, UrlPart value)
{
XmlDocument xmlDoc = null;
string versionUrl = url.ToLower() + "?view=debug";
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(versionUrl);
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
xmlDoc = new XmlDocument();
xmlDoc.Load(response.GetResponseStream());
XmlNodeList nodeList = xmlDoc.DocumentElement.ChildNodes;
if (value.ToString().Equals(Enum.GetName(typeof(UrlPart), 1)))
{
return(nodeList[0].ChildNodes[4].InnerText); //return Locale
}
else if (value.ToString().Equals(Enum.GetName(typeof(UrlPart), 2)))
{
return(nodeList[0].ChildNodes[3].InnerText); //return PageID
}
else if (value.ToString().Equals(Enum.GetName(typeof(UrlPart), 3)))
{
return(nodeList[0].ChildNodes[8].InnerText); //return FamilyVersion
}
else if (value.ToString().Equals(Enum.GetName(typeof(UrlPart), 4)))
{
return(nodeList[0].ChildNodes[2].InnerText); //Retrun HostName
}
else if (value.ToString().Equals(Enum.GetName(typeof(UrlPart), 5)))
{
return(nodeList[0].ChildNodes[5].InnerText); //Return logicalPath
}
else if (value.ToString().Equals(Enum.GetName(typeof(UrlPart), 6)))
{
return(nodeList[0].ChildNodes[6].InnerText); //Return logicalSiteName
}
else
{
return(null);
}
}
public static string GetString(this Uri uri, UrlPart urlPart)
{
var url = uri.OriginalString;
if (!string.IsNullOrEmpty(url))
{
int questionMarkIndex = url.IndexOf('?');
if (urlPart == UrlPart.FullPath)
{
return(url);
}
else if (urlPart == UrlPart.BasePath)
{
if (questionMarkIndex != -1)
{
return(url.Substring(0, questionMarkIndex));
}
else
{
return(url);
}
}
else if (urlPart == UrlPart.QueryString)
{
if (questionMarkIndex != -1 && url.Length > questionMarkIndex + 1)
{
return(url.Substring(questionMarkIndex + 1, url.Length - questionMarkIndex - 1));
}
else
{
return(string.Empty);
}
}
}
return(string.Empty);
}
public MethodParameter(UrlPart urlPart, MethodParameterType type, Term term)
{
UrlPart = urlPart;
Type = type;
Term = term;
}
public Boards(TaskListAppRoot parent, UrlPart urlPart) : base(parent, urlPart, nameof(Boards), TermFactory.From <Boards>())
{
}
public Authentication(TaskListAppRoot parent, UrlPart urlPart) : base(parent, urlPart, nameof(Authentication), TermFactory.From <Authentication>())
{
}
public Task(Card parent, UrlPart urlPart, string title) : base(parent, urlPart, title, TermFactory.From <Task>())
{
}
public bool HasChild(UrlPart urlPart) => this.Items.ContainsKey(urlPart);
/// <summary>
/// Get an array of urlparts, regardless of whether this was mime or not if the stream is mime/multipart also extract that
/// </summary>
/// <param name="connection">Web request/response</param>
/// <returns>The array of body parts input stream </returns>
///
public static UrlPart[] GetURLParts(HttpWebRequest connection)
{
if (connection == null)
{
return(null);
}
string contentType;
try
{
contentType = connection.GetResponse().Headers.Get("Content-Type");
}
catch (ArgumentNullException)
{
contentType = null;
}
string urlContentType = contentType;
if (!MimeUtil.MULTIPART_RELATED.ToLower().Equals(urlContentType.ToLower()))
{
UrlPart p;
try
{
p = new UrlPart(connection);
}
catch (IOException)
{
return(null);
}
return(new UrlPart[] { p });
}
AttachmentCollection attachments;
try
{
attachments = MimeUtil.GetMultiPart(connection.GetResponse().GetResponseStream());
}
catch (IOException)
{
return(null);
}
if (attachments == null)
{
return(null);
}
UrlPart[] parts = new UrlPart[attachments.Count];
int i = 0;
foreach (Attachment attatchment in attachments)
{
try
{
ContentType ct = attatchment.ContentType;
parts[i] = new UrlPart(attatchment);
}
catch (HttpException)
{
parts[i] = null;
}
catch (IOException)
{
parts[i] = null;
}
++i;
}
return(parts);
}
/// <summary>
/// Removes the part from URL address
/// </summary>
/// <param name="part"></param>
/// <returns></returns>
public bool Remove(UrlPart part)
{
return(parts.Remove(part));
}
public void UnsetIndex(UrlPart urlPart)
{
SetIndex(urlPart, -1);
}
public ChessGameNode(ChessGame chessGame, ChessEngineApp parent, UrlPart gameId) : base(parent, gameId, "Game " + gameId, TermFactory.From <ChessGameNode>())
{
_chessGame = chessGame;
}
public Card(Board parent, UrlPart urlPart, string title) : base(parent, urlPart, title, TermFactory.From <Card>())
{
}
public void ProcessParamParts(string[] urlParts, int startIndex)
{
for (int i = startIndex; i < urlParts.Length; i++)
{
if (urlParts[i].Length > 0)
{
UrlPart p = new UrlPart(urlParts[i], i - startIndex);
this.Add(p.Key, p);
}
}
}
public void Add(string key, UrlPart value)
{
if (!this.Contains(key))
innerHash.Add(key.ToLower(), value);
innerIndex.Add(value.Index, value);
}
public bool ContainsValue(UrlPart value)
{
return innerIndex.ContainsValue(value);
}
/// <summary>
/// Converts the URL part to XML element
/// </summary>
/// <param name="part">The part of URL</param>
/// <returns>The XML element, that represents given UML part</returns>
private XElement PartToElement(UrlPart part)
{
return(new XElement("part"));
}
/// <summary>
/// Adds the part in URL address
/// </summary>
/// <param name="part"></param>
public void Add(UrlPart part)
{
parts.Add(part);
}
