private void BuildOptionsParameterTemplateModel()
{
CompositeType optionsType;
optionsType = new CompositeType
{
Name = "options",
SerializedName = "options",
Documentation = "Optional Parameters."
};
var optionsParmeter = new Parameter
{
Name = "options",
SerializedName = "options",
IsRequired = false,
Documentation = "Optional Parameters.",
Location = ParameterLocation.None,
Type = optionsType
};
IEnumerable <ParameterTemplateModel> optionalParameters = LocalParameters.Where(p => !p.IsRequired);
foreach (ParameterTemplateModel parameter in optionalParameters)
{
Property optionalProperty = new Property
{
IsReadOnly = false,
Name = parameter.Name,
IsRequired = parameter.IsRequired,
DefaultValue = parameter.DefaultValue,
Documentation = parameter.Documentation,
Type = parameter.Type,
SerializedName = parameter.SerializedName
};
parameter.Constraints.ToList().ForEach(x => optionalProperty.Constraints.Add(x.Key, x.Value));
parameter.Extensions.ToList().ForEach(x => optionalProperty.Extensions.Add(x.Key, x.Value));
((CompositeType)optionsParmeter.Type).Properties.Add(optionalProperty);
}
//Adding customHeaders to the options object
Property customHeaders = new Property
{
IsReadOnly = false,
Name = "customHeaders",
IsRequired = false,
Documentation = "Headers that will be added to the request",
Type = new PrimaryType(KnownPrimaryType.Object),
SerializedName = "customHeaders"
};
((CompositeType)optionsParmeter.Type).Properties.Add(customHeaders);
OptionsParameterTemplateModel = new ParameterTemplateModel(optionsParmeter);
}
/// <summary>
/// Generate the method parameter declarations for a method, using TypeScript declaration syntax
/// <param name="includeOptions">whether the ServiceClientOptions parameter should be included</param>
/// <param name="isOptionsOptional">whether the ServiceClientOptions parameter should be optional</param>
/// </summary>
public string MethodParameterDeclarationTS(bool includeOptions, bool isOptionsOptional = true)
{
StringBuilder declarations = new StringBuilder();
bool first = true;
IEnumerable <ParameterTS> requiredParameters = LocalParameters.Where(p => p.IsRequired);
foreach (var parameter in requiredParameters)
{
if (!first)
{
declarations.Append(", ");
}
declarations.Append(parameter.Name);
declarations.Append(": ");
// For date/datetime parameters, use a union type to reflect that they can be passed as a JS Date or a string.
var type = parameter.ModelType;
declarations.Append(ProvideParameterType(type));
first = false;
}
if (includeOptions)
{
if (!first)
{
declarations.Append(", ");
}
if (isOptionsOptional)
{
declarations.Append("options?: ");
}
else
{
declarations.Append("options: ");
}
if (OptionsParameterModelType.Name.EqualsIgnoreCase("RequestOptionsBase"))
{
declarations.Append("msRest.RequestOptionsBase");
}
else
{
declarations.AppendFormat("Models.{0}", OptionsParameterModelType.Name);
}
}
return(declarations.ToString());
}
/// <summary>
/// Generate the method parameter declaration for sync methods and extensions
/// </summary>
/// <param name="addCustomHeaderParameters">If true add the customHeader to the parameters</param>
/// <returns>Generated string of parameters</returns>
public virtual string GetSyncMethodParameterDeclaration(bool addCustomHeaderParameters)
{
var declarations = new List <string>();
foreach (var parameter in LocalParameters.Where(x => x.Location != ParameterLocation.Header))
{
var format = (parameter.IsRequired ? "{0} {1}" : "{0} {1} = {2}");
var defaultValue = $"default({parameter.ModelTypeName})";
if (!string.IsNullOrEmpty(parameter.DefaultValue) && parameter.ModelType is PrimaryType)
{
defaultValue = parameter.DefaultValue;
}
declarations.Add(string.Format(CultureInfo.InvariantCulture,
format, parameter.ModelTypeName, parameter.Name, defaultValue));
}
return(string.Join(", ", declarations));
}
/// <summary>
/// Generate the method parameter declarations for a method, using TypeScript declaration syntax
/// <param name="includeOptions">whether the ServiceClientOptions parameter should be included</param>
/// <param name="isOptionsOptional">whether the ServiceClientOptions parameter should be optional</param>
/// </summary>
public string MethodParameterDeclarationTS(bool includeOptions, bool isOptionsOptional = true)
{
TSBuilder builder = new TSBuilder();
TSParameterList parameterList = new TSParameterList(builder);
parameterList.Parameters(LocalParameters.Where(p => p.IsRequired).Select(AutoRestParameterToTSParameter));
if (includeOptions)
{
string optionsParameterType;
if (OptionsParameterModelType.Name.EqualsIgnoreCase("RequestOptionsBase"))
{
optionsParameterType = "msRest.RequestOptionsBase";
}
else
{
optionsParameterType = $"Models.{OptionsParameterModelType.Name}";
}
parameterList.Parameter("options", optionsParameterType, isOptionsOptional);
}
return(builder.ToString());
}
/// <summary>
/// Generate the method parameter declarations for a method, using TypeScript declaration syntax
/// <param name="includeOptions">whether the ServiceClientOptions parameter should be included</param>
/// <param name="isOptionsOptional">whether the ServiceClientOptions parameter should be optional</param>
/// </summary>
public string MethodParameterDeclarationTS(bool includeOptions, bool isOptionsOptional = true)
{
StringBuilder declarations = new StringBuilder();
bool first = true;
IEnumerable <ParameterJs> requiredParameters = LocalParameters.Where(p => p.IsRequired);
foreach (var parameter in requiredParameters)
{
if (!first)
{
declarations.Append(", ");
}
declarations.Append(parameter.Name);
declarations.Append(": ");
// For date/datetime parameters, use a union type to reflect that they can be passed as a JS Date or a string.
var type = parameter.ModelType;
if (type.IsPrimaryType(KnownPrimaryType.Date) || type.IsPrimaryType(KnownPrimaryType.DateTime))
{
declarations.Append("Date|string");
}
else
{
declarations.Append(type.TSType(false));
}
first = false;
}
if (includeOptions)
{
if (!first)
{
declarations.Append(", ");
}
if (isOptionsOptional)
{
declarations.Append("options?: { ");
}
else
{
declarations.Append("options: { ");
}
var optionalParameters = ((CompositeType)OptionsParameterTemplateModel.ModelType).Properties.OrderBy(each => each.Name == "customHeaders" ? 1 : 0).ToArray();
for (int i = 0; i < optionalParameters.Length; i++)
{
if (i != 0)
{
declarations.Append(", ");
}
declarations.Append(optionalParameters[i].Name);
declarations.Append("? : ");
if (optionalParameters[i].Name.EqualsIgnoreCase("customHeaders"))
{
declarations.Append("{ [headerName: string]: string; }");
}
else
{
declarations.Append(optionalParameters[i].ModelType.TSType(false));
}
}
declarations.Append(" }");
}
return(declarations.ToString());
}
protected TSParameter[] GetRequiredParameters()
{
return(LocalParameters.Where(parameter => parameter.IsRequired).Select(AutoRestParameterToTSParameter).ToArray());
}
/// <summary>
/// Generate the method parameter declarations for a method, using TypeScript declaration syntax
/// <param name="includeOptions">whether the ServiceClientOptions parameter should be included</param>
/// </summary>
public string MethodParameterDeclarationTS(bool includeOptions)
{
StringBuilder declarations = new StringBuilder();
bool first = true;
IEnumerable <ParameterTemplateModel> requiredParameters = LocalParameters.Where(p => p.IsRequired);
foreach (var parameter in requiredParameters)
{
if (!first)
{
declarations.Append(", ");
}
declarations.Append(parameter.Name);
declarations.Append(": ");
// For date/datetime parameters, use a union type to reflect that they can be passed as a JS Date or a string.
var type = parameter.Type;
if (type == PrimaryType.Date || type == PrimaryType.DateTime)
{
declarations.Append("Date|string");
}
else
{
declarations.Append(type.TSType(false));
}
first = false;
}
if (includeOptions)
{
if (!first)
{
declarations.Append(", ");
}
declarations.Append("options: { ");
var optionalParameters = ((CompositeType)OptionsParameterTemplateModel.Type).Properties;
for (int i = 0; i < optionalParameters.Count; i++)
{
if (i != 0)
{
declarations.Append(", ");
}
declarations.Append(optionalParameters[i].Name);
declarations.Append("? : ");
if (optionalParameters[i].Name.Equals("customHeaders", StringComparison.OrdinalIgnoreCase))
{
declarations.Append("{ [headerName: string]: string; }");
}
else
{
declarations.Append(optionalParameters[i].Type.TSType(false));
}
}
declarations.Append(" }");
}
return(declarations.ToString());
}
