public GenericHandler(string contentType, EndpointAttributes handlerAttributes, Feature usesFeature)
 {
     this.HandlerContentType = contentType;
     this.ContentTypeAttribute = ContentType.GetEndpointAttributes(contentType);
     this.HandlerAttributes = handlerAttributes;
     this.usesFeature = usesFeature;
 }

 public static MethodInfo GetRunTimeExecMethod(Type serviceType, Type requestType, EndpointAttributes attrs)
 {
     if ((attrs & EndpointAttributes.AsyncOneWay) == EndpointAttributes.AsyncOneWay)
     {
         var mi = serviceType.GetMethod(ExecuteAsync, new[] { requestType });
         if (mi != null) return mi;
     }
     else if ((attrs & EndpointAttributes.HttpGet) == EndpointAttributes.HttpGet)
     {
         var mi = serviceType.GetMethod(RestGet, new[] { requestType });
         if (mi != null) return mi;
     }
     else if ((attrs & EndpointAttributes.HttpPost) == EndpointAttributes.HttpPost)
     {
         var mi = serviceType.GetMethod(RestPost, new[] { requestType });
         if (mi != null) return mi;
     }
     else if ((attrs & EndpointAttributes.HttpPut) == EndpointAttributes.HttpPut)
     {
         var mi = serviceType.GetMethod(RestPut, new[] { requestType });
         if (mi != null) return mi;
     }
     else if ((attrs & EndpointAttributes.HttpDelete) == EndpointAttributes.HttpDelete)
     {
         var mi = serviceType.GetMethod(RestDelete, new[] { requestType });
         if (mi != null) return mi;
     }
     else if ((attrs & EndpointAttributes.HttpPatch) == EndpointAttributes.HttpPatch)
     {
         var mi = serviceType.GetMethod(RestPatch, new[] { requestType });
         if (mi != null) return mi;
     }
     return serviceType.GetMethod(Execute, new[] { requestType });
 }

		public GenericHandler(string contentType, EndpointAttributes handlerAttributes, Feature format)
		{
			this.HandlerContentType = contentType;
			this.ContentTypeAttribute = ContentFormat.GetEndpointAttributes(contentType);
			this.HandlerAttributes = handlerAttributes;
			this.format = format;
		}

        public void GetEndpointAttributes_AcceptsUserHostAddressFormats(string format, EndpointAttributes expected)
        {
            var handler = new TestHandler();
            var request = new Mock<IHttpRequest>();
            request.Expect(req => req.UserHostAddress).Returns(format);
            request.Expect(req => req.IsSecureConnection).Returns(false);
            request.Expect(req => req.HttpMethod).Returns("GET");

            Assert.AreEqual(expected | EndpointAttributes.HttpGet | EndpointAttributes.InSecure, request.Object.GetAttributes());
        }

        public static ICacheTextManager Create(EndpointAttributes endpointAttributes, ICacheClient cacheClient)
        {
            var isXml = (endpointAttributes & EndpointAttributes.Xml)
                        == EndpointAttributes.Xml;

            if (isXml) return new XmlCacheManager(cacheClient);

            var isJson = (endpointAttributes & EndpointAttributes.Json)
                        == EndpointAttributes.Json;

            if (isJson) return new JsonCacheManager(cacheClient);

            var isJsv = (endpointAttributes & EndpointAttributes.Jsv)
                        == EndpointAttributes.Jsv;

            if (isJsv) return new JsvCacheManager(cacheClient);

            throw new NotSupportedException("Only Xml, Json and Jsv CachTextManagers are supported");
        }

        public static void WriteErrorToResponse(this IHttpResponse response,
            EndpointAttributes contentType, string operationName, string errorMessage, Exception ex)
        {
            switch (contentType)
            {
                case EndpointAttributes.Xml:
                    WriteXmlErrorToResponse(response, operationName, errorMessage, ex);
                    break;

                case EndpointAttributes.Json:
                    WriteJsonErrorToResponse(response, operationName, errorMessage, ex);
                    break;

                case EndpointAttributes.Jsv:
                    WriteJsvErrorToResponse(response, operationName, errorMessage, ex);
                    break;

                default:
                    WriteXmlErrorToResponse(response, operationName, errorMessage, ex);
                    break;
            }
        }

 protected GenericHandler(string contentType, EndpointAttributes handlerAttributes)
 {
     this.HandlerContentType = contentType;
     this.ContentTypeAttribute = ContentType.GetEndpointAttributes(contentType);
     this.HandlerAttributes = handlerAttributes;
 }

 internal static object ExecuteService(object request, EndpointAttributes endpointAttributes, IHttpRequest httpReq)
 {
     using (Profiler.Current.Step("Execute Service"))
     {
         return config.ServiceController.Execute(request,
             new HttpRequestContext(httpReq, request, endpointAttributes));
     }
 }

        /// <summary>
        /// Returns the allowed set of scenarios based on the user-specified restrictions
        /// </summary>
        /// <param name="restrictToAny"></param>
        /// <returns></returns>
        private static EndpointAttributes[] ToAllowedFlagsSet(EndpointAttributes[] restrictToAny)
	    {
	        if (restrictToAny.Length == 0)
                return new[] { EndpointAttributes.Any };

	        var scenarios = new List<EndpointAttributes>();
	        foreach (var restrictToScenario in restrictToAny)
	        {
	            var restrictTo = restrictToScenario.ToAllowedFlagsSet();

	            scenarios.Add(restrictTo);
	        }

            return scenarios.ToArray();
	    }

        public bool CanAccess(EndpointAttributes reqAttrs, Format format, string operationName)
        {
            if (EndpointHost.Config != null && !EndpointHost.Config.EnableAccessRestrictions)
                return true;

            Operation operation;
            OperationNamesMap.TryGetValue(operationName.ToLower(), out operation);
            if (operation == null) return false;

            var canCall = HasImplementation(operation, format);
            if (!canCall) return false;

            if (operation.RestrictTo == null) return true;

            var allow = operation.RestrictTo.HasAccessTo(reqAttrs);
            if (!allow) return false;

            var allowsFormat = operation.RestrictTo.HasAccessTo((EndpointAttributes)(long)format);
            return allowsFormat;
        }

 public virtual string ExecuteXmlService(string xmlRequest, EndpointAttributes endpointAttributes)
 {
     return (string)EndpointHost.Config.ServiceController.ExecuteText(
                    	xmlRequest, new HttpRequestContext(xmlRequest, endpointAttributes));
 }

 internal static object ExecuteService(object request, EndpointAttributes endpointAttributes, IHttpRequest httpReq)
 {
     return config.ServiceController.Execute(request,
         new HttpRequestContext(httpReq, request, endpointAttributes));
 }

 internal static object ExecuteService(object request, EndpointAttributes endpointAttributes)
 {
     AssertConfig();
     return Config.ServiceController.Execute(request,
         new HttpRequestContext(request, endpointAttributes));
 }

 public Soap12Handler(EndpointAttributes soapType) : base(soapType) { }

 public PortAttribute(Type operationType, EndpointAttributes endpointAttributes, int version)
     : this(operationType, endpointAttributes)
 {
     this.Version = version;
 }

 public static bool HasAnyRestrictionsOf(EndpointAttributes allRestrictions, EndpointAttributes restrictions)
 {
     return (allRestrictions & restrictions) != 0;
 }

 public bool HasAccessTo(EndpointAttributes restrictions)
 {
     return this.AccessibleToAny.Any(scenario => (restrictions & scenario) == restrictions);
 }

 public bool CanShowTo(EndpointAttributes restrictions)
 {
     return this.VisibleToAny.Any(scenario => (restrictions & scenario) == restrictions);
 }

		//Execute SOAP requests
		protected static string ExecuteXmlService(string xmlRequest, EndpointAttributes endpointAttributes)
		{
			return EndpointHost.ExecuteXmlService(xmlRequest, endpointAttributes);
		}

 public UnauthorizedAccessException UnauthorizedAccess(EndpointAttributes requestAttrs)
 {
     return new UnauthorizedAccessException(
         String.Format("Request with '{0}' is not allowed", requestAttrs));
 }