/// <summary>
/// Genrate code to build an array of query parameter strings in a variable named 'queryParameters'. The
/// array should contain one string element for each query parameter of the form 'key=value'
/// </summary>
/// <param name="builder">The stringbuilder for url construction</param>
protected virtual void BuildQueryParameterArray(IndentedStringBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
builder.AppendLine("var queryParameters = [];");
foreach (var queryParameter in ParameterTemplateModels
.Where(p => p.Location == ParameterLocation.Query))
{
var queryAddFormat = "queryParameters.push('{0}=' + encodeURIComponent({1}));";
if (queryParameter.SkipUrlEncoding())
{
queryAddFormat = "queryParameters.push('{0}=' + {1});";
}
if (!queryParameter.IsRequired)
{
builder.AppendLine("if ({0} !== null && {0} !== undefined) {{", queryParameter.Name)
.Indent()
.AppendLine(queryAddFormat,
queryParameter.SerializedName, queryParameter.GetFormattedReferenceValue()).Outdent()
.AppendLine("}");
}
else
{
builder.AppendLine(queryAddFormat,
queryParameter.SerializedName, queryParameter.GetFormattedReferenceValue());
}
}
}
/// <summary>
/// Generate code to build the URL from a url expression and method parameters.
/// </summary>
/// <param name="inputVariableName">The variable to prepare url from.</param>
/// <param name="outputVariableName">The variable that will keep the url.</param>
/// <returns>Code for URL generation.</returns>
public virtual string BuildUrl(string inputVariableName, string outputVariableName)
{
var builder = new IndentedStringBuilder(" ");
// Filling path parameters (which are directly in the url body).
foreach (var pathParameter in ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path))
{
builder.AppendLine("{0}['{{{1}}}'] = ERB::Util.url_encode({2})",
inputVariableName,
pathParameter.SerializedName,
pathParameter.Type.ToString(pathParameter.Name));
}
// Adding prefix in case of not absolute url.
if (!this.IsAbsoluteUrl)
{
builder.AppendLine("{0} = URI.join({1}.base_url, {2})", outputVariableName, ClientReference, inputVariableName);
}
// Filling query parameters (which are directly in the url query part).
var queryParametres = ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Query).ToList();
if (queryParametres.Any())
{
builder.AppendLine("properties = {{ {0} }}",
string.Join(", ", queryParametres.Select(x => string.Format("'{0}' => {1}", x.SerializedName, x.Name))));
builder.AppendLine("properties.reject!{ |key, value| value.nil? }");
builder.AppendLine("{0}.query = properties.map{{ |key, value| \"#{{key}}=#{{ERB::Util.url_encode(value.to_s)}}\" }}.compact.join('&')", outputVariableName);
}
builder.AppendLine(@"fail URI::Error unless {0}.to_s =~ /\A#{{URI::regexp}}\z/", outputVariableName);
return(builder.ToString());
}
/// <summary>
/// Generate code to build the URL from a url expression and method parameters
/// </summary>
/// <param name="variableName">The variable to store the url in.</param>
/// <returns></returns>
public virtual string BuildUrl(string variableName)
{
var builder = new IndentedStringBuilder();
foreach (var pathParameter in ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path))
{
builder.AppendLine("{0} = {0}.Replace(\"{{{1}}}\", Uri.EscapeDataString({2}));",
variableName,
pathParameter.SerializedName,
pathParameter.Type.ToString(ClientReference, pathParameter.Name));
}
if (ParameterTemplateModels.Any(p => p.Location == ParameterLocation.Query))
{
builder.AppendLine("List<string> queryParameters = new List<string>();");
foreach (var queryParameter in ParameterTemplateModels
.Where(p => p.Location == ParameterLocation.Query))
{
builder.AppendLine("if ({0} != null)", queryParameter.Name)
.AppendLine("{").Indent()
.AppendLine("queryParameters.Add(string.Format(\"{0}={{0}}\", Uri.EscapeDataString({1})));",
queryParameter.SerializedName, queryParameter.GetFormattedReferenceValue(ClientReference)).Outdent()
.AppendLine("}");
}
builder.AppendLine("if (queryParameters.Count > 0)")
.AppendLine("{").Indent()
.AppendLine("{0} += \"?\" + string.Join(\"&\", queryParameters);", variableName).Outdent()
.AppendLine("}");
}
return(builder.ToString());
}
/// <summary>
/// Generate code to build the URL from a url expression and method parameters.
/// </summary>
/// <param name="inputVariableName">The variable to prepare url from.</param>
/// <param name="outputVariableName">The variable that will keep the url.</param>
/// <returns>Code for URL generation.</returns>
public override string BuildUrl(string inputVariableName, string outputVariableName)
{
var builder = new IndentedStringBuilder(" ");
// Filling path parameters (which are directly in the url body).
foreach (var pathParameter in ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path))
{
string variableName = pathParameter.Type.ToString(pathParameter.Name);
string addPathParameterString = String.Format(CultureInfo.InvariantCulture, "{0}['{{{1}}}'] = ERB::Util.url_encode({2})",
inputVariableName,
pathParameter.SerializedName,
variableName);
if (pathParameter.Extensions.ContainsKey(AzureCodeGenerator.SkipUrlEncodingExtension))
{
addPathParameterString = String.Format(CultureInfo.InvariantCulture, "{0}['{{{1}}}'] = {2}",
inputVariableName,
pathParameter.SerializedName,
variableName);
}
builder.AppendLine(addPathParameterString);
}
// Adding prefix in case of not absolute url.
if (!this.IsAbsoluteUrl)
{
builder.AppendLine("{0} = URI.join({1}.base_url, {2})", outputVariableName, ClientReference, inputVariableName);
}
else
{
builder.AppendLine("{0} = URI.parse({1})", outputVariableName, inputVariableName);
}
// Filling query parameters (which are directly in the url query part).
var queryParametres = ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Query).ToList();
builder.AppendLine("properties = {}");
foreach (var param in queryParametres)
{
if (param.Extensions.ContainsKey(AzureCodeGenerator.SkipUrlEncodingExtension))
{
builder.AppendLine("properties['{0}'] = {1} unless {1}.nil?", param.SerializedName, param.Name);
}
else
{
builder.AppendLine("properties['{0}'] = ERB::Util.url_encode({1}.to_s) unless {1}.nil?", param.SerializedName, param.Name);
}
}
builder.AppendLine("properties.reject!{ |key, value| value.nil? }");
builder.AppendLine("{0}.query = properties.map{{ |key, value| \"#{{key}}=#{{value}}\" }}.compact.join('&')", outputVariableName);
builder.AppendLine(@"fail URI::Error unless {0}.to_s =~ /\A#{{URI::regexp}}\z/", outputVariableName);
return(builder.ToString());
}
/// <summary>
/// Initializes a new instance of the AzureMethodTemplateModel class.
/// </summary>
/// <param name="source">The method current model is built for.</param>
/// <param name="serviceClient">The service client - main point of access to the SDK.</param>
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient)
: base(source, serviceClient)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
ParameterTemplateModels.Clear();
source.Parameters.ForEach(p => ParameterTemplateModels.Add(new AzureParameterTemplateModel(p)));
}
/// <summary>
/// Initializes a new instance of the AzureMethodTemplateModel class.
/// </summary>
/// <param name="source">The method current model is built for.</param>
/// <param name="serviceClient">The service client - main point of access to the SDK.</param>
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient)
: base(source, serviceClient)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
ParameterTemplateModels.Clear();
source.Parameters.ForEach(p => ParameterTemplateModels.Add(new AzureParameterTemplateModel(p)));
this.ClientRequestIdString = AzureExtensions.GetClientRequestIdString(source);
this.RequestIdString = AzureExtensions.GetRequestIdString(source);
}
private void ReplacePathParametersInUri(string variableName, IndentedStringBuilder builder)
{
foreach (var pathParameter in ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path))
{
string replaceString = "{0} = {0}.Replace(\"{{{1}}}\", Uri.EscapeDataString({2}));";
if (pathParameter.Extensions.ContainsKey(AzureCodeGenerator.SkipUrlEncodingExtension))
{
replaceString = "{0} = {0}.Replace(\"{{{1}}}\", {2});";
}
builder.AppendLine(replaceString,
variableName,
pathParameter.SerializedName,
pathParameter.Type.ToString(ClientReference, pathParameter.Name));
}
}
/// <summary>
/// Generate code to replace path parameters in the url template with the appropriate values
/// </summary>
/// <param name="variableName">The variable name for the url to be constructed</param>
/// <param name="builder">The string builder for url construction</param>
protected virtual void BuildPathParameters(string variableName, IndentedStringBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
foreach (var pathParameter in ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path))
{
var pathReplaceFormat = "{0} = {0}.replace('{{{1}}}', encodeURIComponent({2}));";
if (pathParameter.SkipUrlEncoding())
{
pathReplaceFormat = "{0} = {0}.replace('{{{1}}}', {2});";
}
builder.AppendLine(pathReplaceFormat, variableName, pathParameter.SerializedName,
pathParameter.Type.ToString(pathParameter.Name));
}
}
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient)
: base(source, serviceClient)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
ParameterTemplateModels.Clear();
LogicalParameterTemplateModels.Clear();
source.Parameters.ForEach(p => ParameterTemplateModels.Add(new AzureParameterTemplateModel(p)));
source.LogicalParameters.ForEach(p => LogicalParameterTemplateModels.Add(new AzureParameterTemplateModel(p)));
if (MethodGroupName != ServiceClient.Name)
{
MethodGroupName = MethodGroupName + "Operations";
}
this.ClientRequestIdString = AzureCodeGenerator.GetClientRequestIdString(source);
this.RequestIdString = AzureCodeGenerator.GetRequestIdString(source);
}
private void AddQueryParametersToUri(string variableName, IndentedStringBuilder builder)
{
builder.AppendLine("List<string> queryParameters = new List<string>();");
if (ParameterTemplateModels.Any(p => p.Location == ParameterLocation.Query))
{
foreach (var queryParameter in ParameterTemplateModels
.Where(p => p.Location == ParameterLocation.Query))
{
string queryParametersAddString =
"queryParameters.Add(string.Format(\"{0}={{0}}\", Uri.EscapeDataString({1})));";
if (queryParameter.SerializedName.Equals("$filter", StringComparison.OrdinalIgnoreCase) &&
queryParameter.Type is CompositeType &&
queryParameter.Location == ParameterLocation.Query)
{
queryParametersAddString =
"queryParameters.Add(string.Format(\"{0}={{0}}\", FilterString.Generate(filter)));";
}
else if (queryParameter.Extensions.ContainsKey(AzureCodeGenerator.SkipUrlEncodingExtension))
{
queryParametersAddString = "queryParameters.Add(string.Format(\"{0}={{0}}\", {1}));";
}
builder.AppendLine("if ({0} != null)", queryParameter.Name)
.AppendLine("{").Indent()
.AppendLine(queryParametersAddString,
queryParameter.SerializedName, queryParameter.GetFormattedReferenceValue(ClientReference))
.Outdent()
.AppendLine("}");
}
}
builder.AppendLine("if (queryParameters.Count > 0)")
.AppendLine("{").Indent()
.AppendLine("{0} += \"?\" + string.Join(\"&\", queryParameters);", variableName).Outdent()
.AppendLine("}");
}
/// <summary>
/// Detremines whether the Uri will have any query string
/// </summary>
/// <returns>True if a query string is possible given the method parameters, otherwise false</returns>
protected virtual bool HasQueryParameters()
{
return(ParameterTemplateModels.Any(p => p.Location == ParameterLocation.Query));
}
