/// <summary>
/// Changes paginated method signatures to return Page type.
/// </summary>
/// <param name="serviceClient"></param>
/// <param name="pageClasses"></param>
public virtual void NormalizePaginatedMethods(ServiceClient serviceClient, IDictionary <KeyValuePair <string, string>, string> pageClasses)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
var convertedTypes = new Dictionary <IType, CompositeType>();
foreach (var method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension)))
{
string nextLinkString;
string pageClassName = GetPagingSetting(method.Extensions, pageClasses, out nextLinkString);
if (string.IsNullOrEmpty(pageClassName))
{
continue;
}
var pageTypeFormat = "{0}<{1}>";
var ipageTypeFormat = "Microsoft.Rest.Azure.IPage<{0}>";
if (string.IsNullOrWhiteSpace(nextLinkString))
{
ipageTypeFormat = "System.Collections.Generic.IEnumerable<{0}>";
}
foreach (var responseStatus in method.Responses
.Where(r => r.Value.Body is CompositeType).Select(s => s.Key).ToArray())
{
var compositType = (CompositeType)method.Responses[responseStatus].Body;
var sequenceType = compositType.Properties.Select(p => p.Type).FirstOrDefault(t => t is SequenceType) as SequenceType;
// if the type is a wrapper over page-able response
if (sequenceType != null)
{
var pagableTypeName = string.Format(CultureInfo.InvariantCulture, pageTypeFormat, pageClassName, sequenceType.ElementType.Name);
var ipagableTypeName = string.Format(CultureInfo.InvariantCulture, ipageTypeFormat, sequenceType.ElementType.Name);
CompositeType pagedResult = new CompositeType
{
Name = pagableTypeName
};
pagedResult.Extensions[AzureExtensions.ExternalExtension] = true;
pagedResult.Extensions[AzureExtensions.PageableExtension] = ipagableTypeName;
convertedTypes[method.Responses[responseStatus].Body] = pagedResult;
method.Responses[responseStatus] = new Response(pagedResult, method.Responses[responseStatus].Headers);
}
}
if (convertedTypes.ContainsKey(method.ReturnType.Body))
{
method.ReturnType = new Response(convertedTypes[method.ReturnType.Body],
method.ReturnType.Headers);
}
}
SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name)));
}
/// <summary>
/// Changes paginated method signatures to return Page type.
/// </summary>
/// <param name="serviceClient"></param>
/// <param name="pageClasses"></param>
public void NormalizePaginatedMethods(CodeModel serviceClient, IDictionary <KeyValuePair <string, string>, string> pageClasses)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
var convertedTypes = new Dictionary <IModelType, IModelType>();
foreach (MethodJva method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension)))
{
string nextLinkString;
string pageClassName = GetPagingSetting(method.Extensions, pageClasses, out nextLinkString);
if (string.IsNullOrEmpty(pageClassName))
{
continue;
}
if (string.IsNullOrEmpty(nextLinkString))
{
method.Extensions[AzureExtensions.PageableExtension] = null;
}
foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeTypeJva).Select(s => s.Key).ToArray())
{
var compositType = (CompositeTypeJva)method.Responses[responseStatus].Body;
var sequenceType = compositType.Properties.Select(p => p.ModelType).FirstOrDefault(t => t is SequenceTypeJva) as SequenceTypeJva;
// if the type is a wrapper over page-able response
if (sequenceType != null)
{
IModelType pagedResult;
pagedResult = new SequenceTypeJva
{
ElementType = sequenceType.ElementType,
PageImplType = pageClassName
};
convertedTypes[method.Responses[responseStatus].Body] = pagedResult;
var resp = New <Response>(pagedResult, method.Responses[responseStatus].Headers) as ResponseJva;
resp.Parent = method;
method.Responses[responseStatus] = resp;
}
}
if (convertedTypes.ContainsKey(method.ReturnType.Body))
{
var resp = New <Response>(convertedTypes[method.ReturnType.Body], method.ReturnType.Headers) as ResponseJva;
resp.Parent = method;
method.ReturnType = resp;
}
}
SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeTypeJva>().Select(t => t.Name.ToString())));
}
/// <summary>
/// Changes paginated method signatures to return Page type.
/// </summary>
/// <param name="codeModel"></param>
private void NormalizePaginatedMethods(CodeModelPya codeModel)
{
if (codeModel == null)
{
throw new ArgumentNullException("codeModel");
}
var convertedTypes = new Dictionary <IModelType, Response>();
foreach (MethodPya method in codeModel.Methods.Where(m => m is MethodPya && m.Extensions.ContainsKey(AzureExtensions.PageableExtension)))
{
foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeType).Select(s => s.Key))
{
var compositType = (CompositeType)method.Responses[responseStatus].Body;
var sequenceType = compositType.Properties.Select(p => p.ModelType).FirstOrDefault(t => t is SequenceType) as SequenceType;
// if the type is a wrapper over page-able response
if (sequenceType != null)
{
var valueType = sequenceType.ElementType;
string valueTypeName = valueType.Name;
if (!codeModel.PageClasses.ContainsKey(valueTypeName))
{
codeModel.PageClasses.Add(valueTypeName, new Dictionary <int, string>());
}
var pagableTypeName = GetPagingSetting(codeModel, compositType, method.Extensions, valueType,
codeModel.PageClasses[valueTypeName], method.SerializedName);
var pagedResult = New <CompositeType>(pagableTypeName);
// make sure the parent reference is set.
pagedResult.CodeModel = codeModel;
method.PagedResponseContentClass = valueType; // Save the content type model
convertedTypes[compositType] = new Response(pagedResult, null);
method.Responses[responseStatus] = convertedTypes[compositType];
break;
}
}
if (convertedTypes.ContainsKey(method.ReturnType.Body))
{
method.ReturnType = convertedTypes[method.ReturnType.Body];
}
}
SwaggerExtensions.RemoveUnreferencedTypes(codeModel, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name.Value)));
}
/// <summary>
/// Changes paginated method signatures to return Page type.
/// </summary>
/// <param name="serviceClient"></param>
private void NormalizePaginatedMethods(ServiceClient serviceClient)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
var convertedTypes = new Dictionary <IType, Response>();
foreach (var method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension)))
{
foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeType).Select(s => s.Key))
{
var compositType = (CompositeType)method.Responses[responseStatus].Body;
var sequenceType = compositType.Properties.Select(p => p.Type).FirstOrDefault(t => t is SequenceType) as SequenceType;
// if the type is a wrapper over page-able response
if (sequenceType != null)
{
string valueType = sequenceType.ElementType.Name;
if (!pageClasses.ContainsKey(valueType))
{
pageClasses.Add(valueType, new Dictionary <int, string>());
}
string pagableTypeName = GetPagingSetting(compositType, method.Extensions, valueType, pageClasses[valueType], method.SerializedName);
CompositeType pagedResult = new CompositeType
{
Name = pagableTypeName
};
convertedTypes[compositType] = new Response(pagedResult, null);
method.Responses[responseStatus] = convertedTypes[compositType];
break;
}
}
if (convertedTypes.ContainsKey(method.ReturnType.Body))
{
method.ReturnType = convertedTypes[method.ReturnType.Body];
}
}
SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name)));
}