public IEnumerable<ControllerMethod> GetMethods(Resource resource, string url, ControllerObject parent, string objectName)
{
var methodsNames = new List<string>();
if (parent != null && parent.Methods != null)
methodsNames = parent.Methods.Select(m => m.Name).ToList();
var generatorMethods = new Collection<ControllerMethod>();
if (resource.Methods == null)
return generatorMethods;
foreach (var method in resource.Methods)
{
var generatedMethod = BuildControllerMethod(url, method, resource, parent);
if (IsVerbForMethod(method))
{
if (methodsNames.Contains(generatedMethod.Name))
generatedMethod.Name = GetUniqueName(methodsNames, generatedMethod.Name, resource.RelativeUri);
if (method.QueryParameters != null && method.QueryParameters.Any())
{
var queryParameters = QueryParametersParser.ParseParameters(method);
generatedMethod.QueryParameters = queryParameters;
}
generatorMethods.Add(generatedMethod);
methodsNames.Add(generatedMethod.Name);
}
}
return generatorMethods;
}
private void AddGeneratedMethod(Resource resource, string url, string objectName, Method method, ICollection<string> methodsNames,
ICollection<ClientGeneratorMethod> generatorMethods)
{
var generatedMethod = BuildClassMethod(url, method, resource);
if (generatedMethod.ReturnType != "string")
{
var returnType = CollectionTypeHelper.GetBaseType(generatedMethod.ReturnType);
generatedMethod.ReturnTypeObject = schemaResponseObjects.Values
.First(o => o.Name == returnType );
generatedMethod.OkReturnType = GetOkReturnType(generatedMethod);
}
uriParametersGenerator.Generate(resource, url, generatedMethod, uriParameterObjects);
if (!IsVerbForMethod(method)) return;
if (methodsNames.Contains(generatedMethod.Name))
generatedMethod.Name = GetUniqueName(methodsNames, generatedMethod.Name, resource.RelativeUri);
GetQueryParameters(objectName, method, generatedMethod);
GetHeaders(objectName, method, generatedMethod);
GetResponseHeaders(objectName, generatedMethod, method);
generatorMethods.Add(generatedMethod);
methodsNames.Add(generatedMethod.Name);
}
protected static void GetInheritedUriParams(IDictionary<string, Parameter> parentUriParameters, Resource resource)
{
foreach (var uriParams in resource.UriParameters)
{
if (!parentUriParameters.ContainsKey(uriParams.Key))
parentUriParameters.Add(uriParams);
}
}
public void Setup()
{
var raml = new RamlParser().Load("files/box.raml");
var raml2 = new RamlParser().Load("files/congo-drones-5-f.raml");
deliveriesResource = raml2.Resources.First(r => r.RelativeUri == "/deliveries");
searchResource = raml.Resources.First(r => r.RelativeUri == "/search");
foldersResource = raml.Resources.First(r => r.RelativeUri == "/folders");
}
private List<Property> GetProperties(IEnumerable<Response> responses, Resource resource, Method method, string key, string fullUrl)
{
var properties = new List<Property>();
foreach (var response in responses)
{
AddProperty(resource, method, key, response, properties, fullUrl);
}
return properties;
}
private ICollection<Resource> GetResources(IDictionary<string, object> dynamicRaml)
{
object value;
var resources = new Resource[0];
if (dynamicRaml.TryGetValue("resources", out value))
resources = ((object[])value).Select(o => new ResourceBuilder().Build((IDictionary<string, object>)o)).ToArray();
return resources;
}
public string Parse(string schema, Resource resource, Method method, string fullUrl)
{
var url = GetResourcePath(resource, fullUrl);
var res = ReplaceReservedParameters(schema, method, url);
res = ReplaceCustomParameters(resource, res);
res = ReplaceParametersWithFunctions(resource, res, url);
return res;
}
public IEnumerable<GeneratorParameter> GetUriParameters(Resource resource, string url)
{
var parameters = resource.BaseUriParameters
.Select(p => new GeneratorParameter { Name = p.Key, Type = NetTypeMapper.Map(p.Value.Type), Description = p.Value.Description })
.ToList();
parameters.AddRange(resource.UriParameters
.Select(p => new GeneratorParameter { Name = p.Key, Type = NetTypeMapper.Map(p.Value.Type), Description = p.Value.Description })
.ToList());
var urlParameters = ExtractParametersFromUrl(url).ToArray();
parameters.AddRange(urlParameters.Where(up => parameters.All(p => up.Name != p.Name)).ToArray());
return parameters;
}
protected string GetComment(Resource resource, BasicInfo method)
{
var description = resource.Description;
if (!string.IsNullOrWhiteSpace(method.Description))
description += string.IsNullOrWhiteSpace(description) ? method.Description : ". " + method.Description;
description = ParserHelpers.RemoveNewLines(description);
if (!string.IsNullOrWhiteSpace(resource.DisplayName))
description += string.IsNullOrWhiteSpace(description) ? resource.DisplayName : " - " + resource.DisplayName;
return description;
}
private void AddMethodsToRootController(IList<ControllerObject> classes, ICollection<string> classesNames, IDictionary<string, ControllerObject> classesObjectsRegistry,
Resource resource, string fullUrl, ControllerObject rootController, IDictionary<string, Parameter> parentUriParameters)
{
var generatedMethods = webApiMethodsGenerator.GetMethods(resource, fullUrl, rootController, rootController.Name, parentUriParameters);
foreach (var method in generatedMethods)
{
rootController.Methods.Add(method);
}
classesNames.Add(rootController.Name);
classesObjectsRegistry.Add(CalculateClassKey("/"), rootController);
classes.Add(rootController);
}
private static string GetResourcePath(Resource resource, string fullUrl)
{
var url = resource.RelativeUri;
url = ReplaceUriParameters(url);
if (string.IsNullOrWhiteSpace(url) || url.Trim() == "/")
{
fullUrl = ReplaceUriParameters(fullUrl);
url = fullUrl;
}
url = url.TrimEnd('/');
if (!url.StartsWith("/"))
url = "/" + url;
return url;
}
protected string GetReturnType(string key, Method method, Resource resource, string fullUrl)
{
if (!method.Responses.Any(r => r.Body != null && r.Body.Any(b => !string.IsNullOrWhiteSpace(b.Value.Schema))))
return "string";
var responses = method.Responses
.Where(r => r.Body != null && r.Body.Any(b => !string.IsNullOrWhiteSpace(b.Value.Schema)))
.ToArray();
var returnType = HandleMultipleSchemaType(responses, resource, method, key, fullUrl);
if (!string.IsNullOrWhiteSpace(returnType))
return returnType;
return "string";
}
private ClientGeneratorMethod BuildClassMethod(string url, Method method, Resource resource)
{
var generatedMethod = new ClientGeneratorMethod
{
Name = NetNamingMapper.GetMethodName(method.Verb ?? "Get" + resource.RelativeUri),
ReturnType = GetReturnType(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, url),
Parameter = GetParameter(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, url),
Comment = GetComment(resource, method),
Url = url,
Verb = NetNamingMapper.Capitalize(method.Verb),
Parent = null,
UseSecurity =
raml.SecuredBy != null && raml.SecuredBy.Any() ||
resource.Methods.Any(m => m.Verb == method.Verb && m.SecuredBy != null && m.SecuredBy.Any())
};
return generatedMethod;
}
public ICollection<ClientGeneratorMethod> GetMethods(Resource resource, string url, ClassObject parent, string objectName)
{
var methodsNames = new List<string>();
if (parent != null)
methodsNames = parent.Methods.Select(m => m.Name).ToList();
var generatorMethods = new Collection<ClientGeneratorMethod>();
if (resource.Methods == null)
return generatorMethods;
foreach (var method in resource.Methods)
{
AddGeneratedMethod(resource, url, objectName, method, methodsNames, generatorMethods);
}
return generatorMethods;
}
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"};
}
public Resource Build(IDictionary<string, object> dynamicRaml)
{
var resource = new Resource();
new BasicInfoBuilder().Set(dynamicRaml, resource);
resource.RelativeUri = dynamicRaml.ContainsKey("relativeUri") ? (string) dynamicRaml["relativeUri"] : null;
resource.BaseUriParameters = ParametersBuilder.GetUriParameters(dynamicRaml, "baseUriParameters");
resource.UriParameters = ParametersBuilder.GetUriParameters(dynamicRaml, "uriParameters");
resource.DisplayName = dynamicRaml.ContainsKey("displayName") ? (string) dynamicRaml["displayName"] : null;
resource.Protocols = ProtocolsBuilder.Get(dynamicRaml);
resource.Resources = GetResources(dynamicRaml);
resource.Methods = dynamicRaml.ContainsKey("methods")
? new MethodsBuilder(((object[]) dynamicRaml["methods"]).Cast<IDictionary<string, object>>()).Get()
: null;
return resource;
}
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;
}
private ControllerMethod BuildControllerMethod(string url, Method method, Resource resource, ControllerObject parent)
{
var relativeUri = UrlGeneratorHelper.GetRelativeUri(url, parent.PrefixUri);
return new ControllerMethod
{
Name = NetNamingMapper.GetMethodName(method.Verb ?? "Get" + resource.RelativeUri),
Parameter = GetParameter(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, url),
UriParameters = uriParametersGenerator.GetUriParameters(resource, url),
ReturnType = GetReturnType(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, url),
Comment = GetComment(resource, method),
Url = relativeUri,
Verb = NetNamingMapper.Capitalize(method.Verb),
Parent = null,
UseSecurity =
raml.SecuredBy != null && raml.SecuredBy.Any() ||
resource.Methods.Any(m => m.Verb == method.Verb && m.SecuredBy != null && m.SecuredBy.Any()),
SecurityParameters = GetSecurityParameters(raml, method)
};
}
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;
}
public Resource Build(IDictionary<string, object> dynamicRaml, IEnumerable<IDictionary<string, ResourceType>> resourceTypes,
IEnumerable<IDictionary<string, Method>> traits, string defaultMediaType)
{
var resource = new Resource();
new BasicInfoBuilder().Set(dynamicRaml, resource);
resource.RelativeUri = dynamicRaml.ContainsKey("relativeUri") ? (string) dynamicRaml["relativeUri"] : null;
resource.BaseUriParameters = ParametersBuilder.GetUriParameters(dynamicRaml, "baseUriParameters");
resource.UriParameters = ParametersBuilder.GetUriParameters(dynamicRaml, "uriParameters");
resource.DisplayName = dynamicRaml.ContainsKey("displayName") ? (string) dynamicRaml["displayName"] : null;
resource.Protocols = ProtocolsBuilder.Get(dynamicRaml);
resource.Resources = GetResources(dynamicRaml, resourceTypes, traits, defaultMediaType);
resource.Methods = GetMethods(dynamicRaml, traits, defaultMediaType);
resource.Annotations = AnnotationsBuilder.GetAnnotations(dynamicRaml);
resource.Is = IsExtractor.Get(dynamicRaml);
return resource;
}
private ControllerObject CreateControllerAndAddMethods(IList<ControllerObject> classes, ICollection<string> classesNames,
IDictionary<string, ControllerObject> classesObjectsRegistry, Resource resource, string fullUrl, IDictionary<string, Parameter> parentUriParameters)
{
var controller = new ControllerObject
{
Name = GetUniqueObjectName(resource, null),
PrefixUri = UrlGeneratorHelper.FixControllerRoutePrefix(fullUrl),
Description = resource.Description,
};
var methods = webApiMethodsGenerator.GetMethods(resource, fullUrl, controller, controller.Name, parentUriParameters);
foreach (var method in methods)
{
controller.Methods.Add(method);
}
classesNames.Add(controller.Name);
classes.Add(controller);
classesObjectsRegistry.Add(CalculateClassKey(fullUrl), controller);
return controller;
}
public void Generate(Resource resource, string url, ClientGeneratorMethod clientGeneratorMethod,
IDictionary<string, ApiObject> uriParameterObjects, IDictionary<string, Parameter> parentUriParameters)
{
var parameters = GetUriParameters(resource, url, parentUriParameters).ToArray();
clientGeneratorMethod.UriParameters = parameters;
if (!parameters.Any())
return;
var name = NetNamingMapper.GetObjectName(url) + "UriParameters";
clientGeneratorMethod.UriParametersType = name;
if (uriParameterObjects.ContainsKey(name))
return;
var properties = new List<Property>();
if (resource.BaseUriParameters != null)
properties.AddRange(QueryParametersParser.ConvertParametersToProperties(resource.BaseUriParameters));
if (resource.UriParameters != null)
properties.AddRange(QueryParametersParser.ConvertParametersToProperties(resource.UriParameters)
.Where(up => properties.All(p => !String.Equals(up.Name, p.Name, StringComparison.InvariantCultureIgnoreCase))));
var urlParameters = ExtractParametersFromUrl(url).ToArray();
var matchedParameters = MatchParameters(parentUriParameters, urlParameters);
foreach (var urlParameter in matchedParameters)
{
var property = ConvertGeneratorParamToProperty(urlParameter);
if (properties.All(p => !String.Equals(property.Name, p.Name, StringComparison.InvariantCultureIgnoreCase)))
properties.Add(property);
}
var apiObject = new ApiObject
{
Name = name,
Description = "Uri Parameters for resource " + resource.RelativeUri,
Properties = properties
};
uriParameterObjects.Add(name, apiObject);
}
private string HandleMultipleSchemaType(IEnumerable<Response> responses, Resource resource, Method method, string key, string fullUrl)
{
var properties = GetProperties(responses, resource, method, key, fullUrl);
if (properties.Count == 0)
return "string";
if (properties.Count == 1)
return properties.First().Type;
// Build a new response object containing all types
var name = NetNamingMapper.GetObjectName("Multiple" + key);
var apiObject = new ApiObject
{
Name = name,
Description = "Multiple Response Types " + string.Join(", ", properties.Select(p => p.Name)),
Properties = properties,
IsMultiple = true
};
schemaResponseObjects.Add(new KeyValuePair<string, ApiObject>(name, apiObject));
return name;
}
private void AddProperty(Resource resource, Method method, string key, Response response, ICollection<Property> properties, string fullUrl)
{
var mimeType = GeneratorServiceHelper.GetMimeType(response);
if (mimeType == null)
return;
var type = GetReturnTypeFromResponse(method, resource, mimeType, key, response.Code, fullUrl);
if (string.IsNullOrWhiteSpace(type))
return;
var property = new Property
{
Name = CollectionTypeHelper.GetBaseType(type),
Description = response.Description + " " + mimeType.Description,
Example = mimeType.Example,
Type = type,
StatusCode = (HttpStatusCode) Enum.Parse(typeof (HttpStatusCode), response.Code),
JSONSchema = mimeType.Schema == null ? null : mimeType.Schema.Replace(Environment.NewLine, "").Replace("\r\n", "").Replace("\n", "").Replace("\"", "\\\"")
};
properties.Add(property);
}
public void Should_Generate_One_Method_Per_Verb()
{
var methods = new List<Method>
{
new Method
{
Verb = "get"
},
new Method
{
Verb = "post"
}
};
var resource = new Resource
{
RelativeUri = "/abc{token}{code}",
Methods = methods,
};
var schemaResponseObjects = new Dictionary<string, ApiObject>();
var schemaRequestObjects = new Dictionary<string, ApiObject>();
var ramlDocument = new RamlDocument();
var uriParameterObjects = new Dictionary<string, ApiObject>();
var queryObjects = new Dictionary<string, ApiObject>();
var headerObjects = new Dictionary<string, ApiObject>();
var responseHeadersObjects = new Dictionary<string, ApiObject>();
var linkedKeyWithObjectNames = new Dictionary<string, string>();
var classObject = new ClassObject();
var schemaObjects = new Dictionary<string, ApiObject>();
var generator = new ClientMethodsGenerator(ramlDocument, schemaResponseObjects,
uriParameterObjects, queryObjects, headerObjects, responseHeadersObjects, schemaRequestObjects, linkedKeyWithObjectNames,
schemaObjects);
var generatorMethods = generator.GetMethods(resource, "/", classObject, "Test", new Dictionary<string, Parameter>());
Assert.AreEqual(2, generatorMethods.Count);
}
public void Should_Build_Uri_Parameters()
{
var uriParameters = new Dictionary<string, Parameter>
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get"
}
};
var resource = new Resource
{
RelativeUri = "/abc{token}{code}",
Methods = methods,
UriParameters = uriParameters
};
var generator = new UriParametersGenerator();
var uriParameterObjects = new Dictionary<string, ApiObject>();
var generatorMethod = new ClientGeneratorMethod { Name = "MethodOne"};
generator.Generate(resource, "/movies/{bucket}/abc{token}{code}", generatorMethod, uriParameterObjects);
Assert.AreEqual(1, uriParameterObjects.Count);
Assert.AreEqual(3, generatorMethod.UriParameters.Count());
Assert.AreEqual(uriParameterObjects.First().Value.Name, generatorMethod.UriParametersType);
}
public RamlDocument GetRaml(string title = null)
{
if (string.IsNullOrWhiteSpace(title))
title = "Api";
var raml = new RamlDocument {Title = title, BaseUri = baseUri};
var resourcesDic = new Dictionary<string, Resource>();
var parameterDescriptionsDic = new Dictionary<string, Collection<ApiParameterDescription>>();
foreach (var api in apiExplorer.ApiDescriptions)
{
var relativeUri = !api.Route.RouteTemplate.StartsWith("/") ? "/" + api.Route.RouteTemplate : api.Route.RouteTemplate;
if (relativeUri.Contains("{controller}"))
{
relativeUri = relativeUri.Replace("{controller}", api.ActionDescriptor.ControllerDescriptor.ControllerName);
if (relativeUri.EndsWith("/"))
relativeUri = relativeUri.Substring(0, relativeUri.Length - 1);
}
foreach (var apiParam in GetParametersFromUrl(relativeUri))
{
relativeUri = RemoveNonExistingParametersFromRoute(relativeUri, api, apiParam.Key);
}
Resource resource;
if (!resourcesDic.ContainsKey(relativeUri))
{
resource = new Resource
{
Methods = GetMethods(api, new Collection<string>()),
RelativeUri = relativeUri,
};
parameterDescriptionsDic.Add(relativeUri, api.ParameterDescriptions);
resourcesDic.Add(relativeUri, resource);
}
else
{
resource = resourcesDic[relativeUri];
foreach (var apiParameterDescription in api.ParameterDescriptions)
{
parameterDescriptionsDic[relativeUri].Add(apiParameterDescription);
}
AddMethods(resource, api, resource.Methods.Select(m => m.Verb).ToList());
}
if(SetResourceProperties != null)
SetResourceProperties(resource, api);
if(SetResourcePropertiesByAction != null)
SetResourcePropertiesByAction(resource, api.ActionDescriptor);
if(SetResourcePropertiesByController != null)
SetResourcePropertiesByController(resource, api.ActionDescriptor.ControllerDescriptor);
}
raml.Schemas = new List<IDictionary<string, string>> { schemas };
OrganizeResourcesHierarchically(raml, resourcesDic);
SetUriParameters(raml.Resources, parameterDescriptionsDic, string.Empty);
if(SetRamlProperties != null)
SetRamlProperties(raml);
if (SecuritySchemes != null)
raml.SecuritySchemes = SecuritySchemes;
if (!string.IsNullOrWhiteSpace(securityType) && securityScheme != null)
SetSecurityScheme(raml);
if (SecuredBy != null)
raml.SecuredBy = SecuredBy;
if(Protocols != null)
raml.Protocols = Protocols;
return raml;
}
private void AddMethods(Resource resource, ApiDescription api, ICollection<string> verbs)
{
var methods = resource.Methods.ToList();
var newMethods = GetMethods(api, verbs);
methods.AddRange(newMethods);
resource.Methods = methods;
}
private void SerializeResource(StringBuilder sb, Resource resource, int indentation)
{
sb.AppendLine((resource.RelativeUri + ":").Indent(indentation));
SerializeParameters(sb, "baseUriParameters", resource.BaseUriParameters, indentation + 2);
SerializeDescriptionProperty(sb, resource.Description, indentation + 2);
SerializeProperty(sb, "displayName", resource.DisplayName, indentation + 2);
SerializeProtocols(sb, resource.Protocols, indentation + 2);
SerializeParameters(sb, "uriParameters", resource.UriParameters, indentation + 2);
SerializeMethods(sb, resource.Methods, indentation + 2);
//SerializeType(sb, resource.Type, indentation + 2);
SerializeResources(sb, resource.Resources, indentation + 2);
}
// avois infinite recursion
private string GetReturnTypeFromResponseWithoutCheckingResourceTypes(Method method, Resource resource, MimeType mimeType, string key, string responseCode, string fullUrl)
{
var returnType = GetNamedReturnType(method, resource, mimeType, fullUrl);
if (!string.IsNullOrWhiteSpace(returnType))
return returnType;
if (ResponseHasKey(key))
return GetReturnTypeFromResponseByKey(key);
var responseKey = key + ParserHelpers.GetStatusCode(responseCode) + GeneratorServiceBase.ResponseContentSuffix;
if (ResponseHasKey(responseKey))
return GetReturnTypeFromResponseByKey(responseKey);
if (linkKeysWithObjectNames.ContainsKey(key))
{
var linkedKey = linkKeysWithObjectNames[key];
if (ResponseHasKey(linkedKey))
return GetReturnTypeFromResponseByKey(linkedKey);
}
if (linkKeysWithObjectNames.ContainsKey(responseKey))
{
var linkedKey = linkKeysWithObjectNames[responseKey];
if (ResponseHasKey(linkedKey))
return GetReturnTypeFromResponseByKey(linkedKey);
}
return returnType;
}