DeviceEmotion/ApiService/http_vhost/VHostRedirect.cs

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace System.Net.ApiService.VHost_Server {
    public class VHostRedirect {

        private string _redirectHost = "localhost";
        private ushort _redirectPort = 8080;

        private List<VHostRedirectCondition> _conditions = new List<VHostRedirectCondition>();


        public VHostRedirect(string redirect) {
            if(redirect.Contains(':')) {
                string[] r = redirect.Split(':');
                this._redirectHost = r[0];
                if (!ushort.TryParse(r[1], out this._redirectPort))
                    this._redirectPort = 8080;
                if (String.IsNullOrEmpty(this._redirectHost))
                    this._redirectHost = "localhost";
            }
        }

        public VHostRedirect(string redirect, VHostRedirectCondition Condition) {
            if (redirect.Contains(':')) {
                string[] r = redirect.Split(':');
                this._redirectHost = r[0];
                if (!ushort.TryParse(r[1], out this._redirectPort))
                    this._redirectPort = 8080;
                if (String.IsNullOrEmpty(this._redirectHost))
                    this._redirectHost = "localhost";
            }
            this.Conditions.Add(Condition);
        }

        public VHostRedirect(string redirect, VHostRedirectCondition[] Conditions) {
            if (redirect.Contains(':')) {
                string[] r = redirect.Split(':');
                this._redirectHost = r[0];
                if (!ushort.TryParse(r[1], out this._redirectPort))
                    this._redirectPort = 8080;
                if (String.IsNullOrEmpty(this._redirectHost))
                    this._redirectHost = "localhost";
            }
            this.Conditions.AddRange(Conditions);
        }

        public VHostRedirect(ushort redirectPort, VHostRedirectCondition Condition) {
            this._redirectPort = redirectPort;
            this.Conditions.Add(Condition);
        }

        public VHostRedirect(ushort redirectPort, VHostRedirectCondition[] Conditions) {
            this._redirectPort = redirectPort;
            this.Conditions.AddRange(Conditions);
        }

        public VHostRedirect(ushort redirectPort) {
            this._redirectPort = redirectPort;
        }

        public VHostRedirect(string redirectHost, ushort redirectPort) {
            this._redirectHost = redirectHost;
            this._redirectPort = redirectPort;
            if (String.IsNullOrEmpty(this._redirectHost))
                this._redirectHost = "localhost";
        }

        public VHostRedirect(string redirectHost, ushort redirectPort, VHostRedirectCondition Condition) {
            this._redirectHost = redirectHost;
            this._redirectPort = redirectPort;
            if (String.IsNullOrEmpty(this._redirectHost))
                this._redirectHost = "localhost";
            this.Conditions.Add(Condition);
        }

        public VHostRedirect(string redirectHost, ushort redirectPort, VHostRedirectCondition[] Conditions) {
            this._redirectHost = redirectHost;
            this._redirectPort = redirectPort;
            if (String.IsNullOrEmpty(this._redirectHost))
                this._redirectHost = "localhost";
            this.Conditions.AddRange(Conditions);
        }

        public List<VHostRedirectCondition> Conditions => this._conditions;

        public string RedirectHost => this._redirectHost;

        public ushort RedirectPort => this._redirectPort;

        public bool IsMatch(RequestHeader request) {
            foreach(VHostRedirectCondition cond in this._conditions) {
                if (cond.Active) {

                    if (cond.HeaderVariable == VHostRedirectCondition.eVaraible.Host) {
                        if (request.Host == null) {
                            System.Diagnostics.Debug.WriteLine("  - Header Condition: NULL match " + cond.HeaderValue + " = False");
                            return false;
                        } else {
                            bool bIsMatch = Regex.IsMatch(request.Host, cond.HeaderValue);
                            System.Diagnostics.Debug.WriteLine("  - Header Condition: " + request.Host + " match " + cond.HeaderValue + " = " + (bIsMatch ? "True" : "False"));
                            if (cond.ConditionType == VHostRedirectCondition.eCondition.Must && bIsMatch == false)
                                return false;
                            if (cond.ConditionType == VHostRedirectCondition.eCondition.MustNot && bIsMatch == true)
                                return false;
                        }
                    }

                    else if (cond.HeaderVariable == VHostRedirectCondition.eVaraible.Method) {
                        bool bIsMatch = (cond.HeaderValue.ToLower().Trim() == "connect" && (request.Method | HttpMethod.CONNECT) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "delete" && (request.Method | HttpMethod.DELETE) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "get" && (request.Method | HttpMethod.GET) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "options" && (request.Method | HttpMethod.OPTIONS) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "patch" && (request.Method | HttpMethod.PATCH) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "post" && (request.Method | HttpMethod.POST) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "put" && (request.Method | HttpMethod.PUT) == request.Method) ||
                                        (cond.HeaderValue.ToLower().Trim() == "trace" && (request.Method | HttpMethod.TRACE) == request.Method);
                        System.Diagnostics.Debug.WriteLine("  - Method Condition: " + request.Method.ToString() + " match " + cond.HeaderValue + " = " + (bIsMatch ? "True" : "False"));
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.Must && bIsMatch == false)
                            return false;
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.MustNot && bIsMatch == true)
                            return false;
                    } 
                    
                    else if (cond.HeaderVariable == VHostRedirectCondition.eVaraible.Path) {
                        bool bIsMatch = Regex.IsMatch(request.Path, cond.HeaderValue);
                        System.Diagnostics.Debug.WriteLine("  - Path Condition: " + request.Path + " match " + cond.HeaderValue + " = " + (bIsMatch ? "True" : "False"));
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.Must && bIsMatch == false)
                            return false;
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.MustNot && bIsMatch == true)
                            return false;
                    } 
                    
                    else if (cond.HeaderVariable == VHostRedirectCondition.eVaraible.Query) {
                        bool bIsMatch = Regex.IsMatch(request.QueryString, cond.HeaderValue);
                        System.Diagnostics.Debug.WriteLine("  - Query Condition: " + request.QueryString + " match " + cond.HeaderValue + " = " + (bIsMatch ? "True" : "False"));
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.Must && bIsMatch == false)
                            return false;
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.MustNot && bIsMatch == true)
                            return false;
                    } 
                    
                    else if (cond.HeaderVariable == VHostRedirectCondition.eVaraible.Referer) {
                        bool bIsMatch = Regex.IsMatch(request.Referer, cond.HeaderValue);
                        System.Diagnostics.Debug.WriteLine("  - Referer Condition: " + request.Referer + " match " + cond.HeaderValue + " = " + (bIsMatch ? "True" : "False"));
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.Must && bIsMatch == false)
                            return false;
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.MustNot && bIsMatch == true)
                            return false;
                    } 
                    
                    else if (cond.HeaderVariable == VHostRedirectCondition.eVaraible.UserAgent) {
                        bool bIsMatch = Regex.IsMatch(request.UserAgent, cond.HeaderValue);
                        System.Diagnostics.Debug.WriteLine("  - UserAgent Condition: " + request.UserAgent + " match " + cond.HeaderValue + " = " + (bIsMatch ? "True" : "False"));
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.Must && bIsMatch == false)
                            return false;
                        if (cond.ConditionType == VHostRedirectCondition.eCondition.MustNot && bIsMatch == true)
                            return false;
                    }
                }
            }
            return true;
        }
    }
}