protected GeneratorParameter GetParameter(string key, Method method, Resource resource, string fullUrl)
        {
            var schema = GetJsonSchemaOrDefault(method.Body);
            if (schema != null)
            {
                var generatorParameter = GetGeneratorParameterWhenNamed(method, resource, schema, fullUrl);
                if (generatorParameter != null)
                    return generatorParameter;
            }

            if (resource.Type != null && resource.Type.Any() && raml.ResourceTypes.Any(rt => rt.ContainsKey(resource.GetResourceType())))
            {
                var verb = GetResourceTypeVerb(method, resource);
                if (verb != null && verb.Body != null && !string.IsNullOrWhiteSpace(verb.Body.Schema))
                {
                    var generatorParameter = GetGeneratorParameterWhenNamed(method, resource, verb.Body.Schema, fullUrl);
                    if (generatorParameter != null)
                        return generatorParameter;
                }
            }

            if (RequestHasKey(key))
                return GetGeneratorParameterByKey(key);

            var requestKey = key + GeneratorServiceBase.RequestContentSuffix;
            if (RequestHasKey(requestKey))
                return GetGeneratorParameterByKey(requestKey);

            if (linkKeysWithObjectNames.ContainsKey(key))
            {
                var linkedKey = linkKeysWithObjectNames[key];
                if (RequestHasKey(linkedKey))
                    return GetGeneratorParameterByKey(linkedKey);
            }

            if (linkKeysWithObjectNames.ContainsKey(requestKey))
            {
                var linkedKey = linkKeysWithObjectNames[requestKey];
                if (RequestHasKey(linkedKey))
                    return GetGeneratorParameterByKey(linkedKey);
            }

            return new GeneratorParameter {Name = "content", Type = "string"};
        }
	    private static string ReplaceCustomParameters(Resource resource, string res)
	    {
	        var regex = new Regex(@"\<\<([^>]+)\>\>", RegexOptions.IgnoreCase);
	        var matchCollection = regex.Matches(res);
	        foreach (Match match in matchCollection)
	        {
                if(resource.Type == null)
                    continue;

	            var paramFound = match.Groups[1].Value;
	            var type = resource.GetResourceType();
	            if (string.IsNullOrWhiteSpace(type) || !resource.Type.ContainsKey(type) || resource.Type[type] == null || !resource.Type[type].ContainsKey(paramFound))
	                continue;

	            var value = resource.Type[type][paramFound];
	            res = res.Replace("<<" + paramFound + ">>", value);
	        }

	        return res;
	    }
        private string GetReturnTypeFromResourceType(Method method, Resource resource, string key, string responseCode, string fullUrl)
        {
            var returnType = string.Empty;
            if (resource.Type == null || !resource.Type.Any() ||
                !raml.ResourceTypes.Any(rt => rt.ContainsKey(resource.GetResourceType())))
                return returnType;

            var verb = GetResourceTypeVerb(method, resource);
            if (verb == null || verb.Responses == null
                || !verb.Responses.Any(r => r != null && r.Body != null
                                            && r.Body.Values.Any(m => !string.IsNullOrWhiteSpace(m.Schema))))
                return returnType;

            var response = verb.Responses.FirstOrDefault(r => r.Code == responseCode);
            if (response == null)
                return returnType;

            var resourceTypeMimeType = GeneratorServiceHelper.GetMimeType(response);
            if (resourceTypeMimeType != null)
            {
                returnType = GetReturnTypeFromResponseWithoutCheckingResourceTypes(method, resource, resourceTypeMimeType, key, responseCode, fullUrl);
            }
            return returnType;
        }
 protected Verb GetResourceTypeVerb(Method method, Resource resource)
 {
     var resourceTypes = raml.ResourceTypes.First(rt => rt.ContainsKey(resource.GetResourceType()));
     var resourceType = resourceTypes[resource.GetResourceType()];
     Verb verb;
     switch (method.Verb)
     {
         case "get":
             verb = resourceType.Get;
             break;
         case "delete":
             verb = resourceType.Delete;
             break;
         case "post":
             verb = resourceType.Post;
             break;
         case "put":
             verb = resourceType.Put;
             break;
         case "patch":
             verb = resourceType.Patch;
             break;
         case "options":
             verb = resourceType.Options;
             break;
         default:
             throw new InvalidOperationException("Verb not found " + method.Verb);
     }
     return verb;
 }
	    private string ReplaceParametersWithFunctions(Resource resource, string res, string url)
	    {
	        var regex = new Regex(@"\<\<([a-z_-]+)\s?\|\s?\!(pluralize|singularize)\>\>", RegexOptions.IgnoreCase);
	        var matchCollection = regex.Matches(res);
	        foreach (Match match in matchCollection)
	        {
	            string replacementWord;
	            switch (match.Groups[1].Value)
	            {
	                case "resourcePathName":
	                    replacementWord = url.Substring(1);
	                    break;
	                case "resourcePath":
	                    replacementWord = url.Substring(1);
	                    break;
	                case "methodName":
	                    replacementWord = url.Substring(1);
	                    break;
	                default:
	                    var paramFound = match.Groups[1].Value;
	                    var type = resource.GetResourceType();
	                    if (string.IsNullOrWhiteSpace(type))
	                        continue;

	                    if (!resource.Type[type].ContainsKey(paramFound))
	                        continue;

	                    replacementWord = resource.Type[type][paramFound];
	                    break;
	            }

	            if (match.Groups[2].Value == "singularize")
	            {
	                res = res.Replace(match.Groups[0].Value, Singularize(replacementWord));
	            }
	            else if (match.Groups[2].Value == "pluralize")
	            {
	                res = res.Replace(match.Groups[0].Value, Pluralize(replacementWord));
	            }
	        }
	        return res;
	    }