private static string BuildNullCheckExpression(ParameterTransformation transformation)
{
if (transformation == null)
{
throw new ArgumentNullException("transformation");
}
return(string.Join(" || ",
transformation.ParameterMappings.Select(m => m.InputParameter.Name + " != null")));
}
private static string BuildNullCheckExpression(ParameterTransformation transformation)
{
if (transformation == null)
{
throw new ArgumentNullException("transformation");
}
return(string.Join(" or ",
transformation.ParameterMappings.Select(m =>
string.Format(CultureInfo.InvariantCulture,
"{0} is not None", m.InputParameter.Name))));
}
/// <summary>
/// Flattens the request payload if the number of properties of the
/// payload is less than or equal to the PayloadFlatteningThreshold.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
public static void FlattenMethodParameters(ServiceClient serviceClient, Settings settings)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
foreach (var method in serviceClient.Methods)
{
var bodyParameter = method.Parameters.FirstOrDefault(
p => p.Location == ParameterLocation.Body);
if (bodyParameter != null)
{
var bodyParameterType = bodyParameter.Type as CompositeType;
if (bodyParameterType != null &&
(bodyParameterType.ComposedProperties.Count(p => !p.IsConstant) <= settings.PayloadFlatteningThreshold ||
bodyParameter.ShouldBeFlattened()))
{
var parameterTransformation = new ParameterTransformation
{
OutputParameter = bodyParameter
};
method.InputParameterTransformation.Add(parameterTransformation);
foreach (var property in bodyParameterType.ComposedProperties.Where(p => !p.IsConstant && p.Name != null))
{
var newMethodParameter = new Parameter();
newMethodParameter.LoadFrom(property);
var documentationString = !string.IsNullOrEmpty(property.Summary) ? property.Summary + " " : string.Empty;
documentationString += property.Documentation;
newMethodParameter.Documentation = documentationString;
bodyParameter.Extensions.ForEach(kv => { newMethodParameter.Extensions[kv.Key] = kv.Value; });
method.Parameters.Add(newMethodParameter);
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = newMethodParameter,
OutputParameterProperty = property.GetClientName()
});
}
method.Parameters.Remove(bodyParameter);
}
}
}
}
/// <summary>
/// Flattens the request payload if the number of properties of the
/// payload is less than or equal to the PayloadFlatteningThreshold.
/// </summary>
/// <param name="codeModelient">Service client</param>
/// <param name="settings">AutoRest settings</param>
public static void FlattenMethodParameters(CodeModel codeModel)
{
if (codeModel == null)
{
throw new ArgumentNullException("codeModel");
}
foreach (var method in codeModel.Methods)
{
var bodyParameter = method.Parameters.FirstOrDefault(
p => p.Location == ParameterLocation.Body);
if (bodyParameter != null)
{
var bodyParameterType = bodyParameter.ModelType as CompositeType;
if (bodyParameterType != null &&
!bodyParameterType.BaseIsPolymorphic &&
(bodyParameterType.ComposedProperties.Count(p => !p.IsConstant && !p.IsReadOnly) <= Settings.Instance.PayloadFlatteningThreshold ||
bodyParameter.ShouldBeFlattened()))
{
var parameterTransformation = new ParameterTransformation
{
OutputParameter = bodyParameter
};
method.InputParameterTransformation.Add(parameterTransformation);
method.Remove(bodyParameter);
foreach (var property in bodyParameterType.ComposedProperties.Where(p => !p.IsConstant && p.Name != null && !p.IsReadOnly))
{
var newMethodParameter = New <Parameter>();
newMethodParameter.LoadFrom(property);
var documentationString = !string.IsNullOrEmpty(property.Summary) ? property.Summary + " " : string.Empty;
documentationString += property.Documentation;
newMethodParameter.Documentation = documentationString;
bodyParameter.Extensions.ForEach(kv => { newMethodParameter.Extensions[kv.Key] = kv.Value; });
method.Add(newMethodParameter);
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = newMethodParameter,
OutputParameterProperty = property.GetClientName()
});
}
}
}
}
}
/// <summary>
/// Flattens the request payload if the number of properties of the
/// payload is less than or equal to the PayloadFlatteningThreshold.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
public static void FlattenRequestPayload(ServiceClient serviceClient, Settings settings)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
foreach (var method in serviceClient.Methods)
{
var bodyParameter = method.Parameters.FirstOrDefault(
p => p.Location == ClientModel.ParameterLocation.Body);
if (bodyParameter != null)
{
var bodyParameterType = bodyParameter.Type as CompositeType;
if (bodyParameterType != null && bodyParameterType.ComposedProperties.Count(p => !p.IsConstant) <= settings.PayloadFlatteningThreshold)
{
var parameterTransformation = new ParameterTransformation
{
OutputParameter = bodyParameter
};
method.InputParameterTransformation.Add(parameterTransformation);
foreach (var property in bodyParameterType.ComposedProperties.Where(p => !p.IsConstant))
{
var newMethodParameter = new Parameter();
newMethodParameter.LoadFrom(property);
method.Parameters.Add(newMethodParameter);
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = newMethodParameter,
OutputParameterProperty = property.Name
});
}
method.Parameters.Remove(bodyParameter);
}
}
}
}
/// <summary>
/// Builds null check expression for the given <paramref name="transformation"/>.
/// </summary>
/// <param name="transformation">ParameterTransformation for which to build null check expression.</param>
/// <returns></returns>
private static string BuildNullCheckExpression(ParameterTransformation transformation)
{
if (transformation == null)
{
throw new ArgumentNullException("transformation");
}
if (transformation.ParameterMappings.Count == 1)
{
return(string.Format(CultureInfo.InvariantCulture,
"{0}.nil?", transformation.ParameterMappings[0].InputParameter.Name));
}
else
{
return(string.Join(" && ",
transformation.ParameterMappings.Select(m =>
string.Format(CultureInfo.InvariantCulture,
"{0}.nil?", m.InputParameter.Name))));
}
}
/// <summary>
/// Adds the parameter groups to operation parameters.
/// </summary>
/// <param name="serviceClient"></param>
public static void AddParameterGroups(ServiceClient serviceClient)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
HashSet <CompositeType> generatedParameterGroups = new HashSet <CompositeType>();
foreach (Method method in serviceClient.Methods)
{
//Copy out flattening transformations as they should be the last
List <ParameterTransformation> flatteningTransformations = method.InputParameterTransformation.ToList();
method.InputParameterTransformation.Clear();
//This group name is normalized by each languages code generator later, so it need not happen here.
Dictionary <string, Dictionary <Property, Parameter> > parameterGroups = new Dictionary <string, Dictionary <Property, Parameter> >();
foreach (Parameter parameter in method.Parameters)
{
if (parameter.Extensions.ContainsKey(ParameterGroupExtension))
{
JContainer extensionObject = parameter.Extensions[ParameterGroupExtension] as JContainer;
if (extensionObject != null)
{
string specifiedGroupName = extensionObject.Value <string>("name");
string parameterGroupName;
if (specifiedGroupName == null)
{
string postfix = extensionObject.Value <string>("postfix") ?? "Parameters";
parameterGroupName = method.Group + "-" + method.Name + "-" + postfix;
}
else
{
parameterGroupName = specifiedGroupName;
}
if (!parameterGroups.ContainsKey(parameterGroupName))
{
parameterGroups.Add(parameterGroupName, new Dictionary <Property, Parameter>());
}
Property groupProperty = new Property()
{
IsReadOnly = false, //Since these properties are used as parameters they are never read only
Name = parameter.Name,
IsRequired = parameter.IsRequired,
DefaultValue = parameter.DefaultValue,
//Constraints = parameter.Constraints, Omit these since we don't want to perform parameter validation
Documentation = parameter.Documentation,
Type = parameter.Type,
SerializedName = null //Parameter is never serialized directly
};
// Copy over extensions
foreach (var key in parameter.Extensions.Keys)
{
groupProperty.Extensions[key] = parameter.Extensions[key];
}
parameterGroups[parameterGroupName].Add(groupProperty, parameter);
}
}
}
foreach (string parameterGroupName in parameterGroups.Keys)
{
CompositeType parameterGroupType =
generatedParameterGroups.FirstOrDefault(item => item.Name == parameterGroupName);
if (parameterGroupType == null)
{
parameterGroupType = new CompositeType
{
Name = parameterGroupName,
Documentation = "Additional parameters for the " + method.Name + " operation."
};
generatedParameterGroups.Add(parameterGroupType);
//Add to the service client
serviceClient.ModelTypes.Add(parameterGroupType);
}
foreach (Property property in parameterGroups[parameterGroupName].Keys)
{
Property matchingProperty = parameterGroupType.Properties.FirstOrDefault(
item => item.Name == property.Name &&
item.IsReadOnly == property.IsReadOnly &&
item.DefaultValue == property.DefaultValue &&
item.SerializedName == property.SerializedName);
if (matchingProperty == null)
{
parameterGroupType.Properties.Add(property);
}
}
bool isGroupParameterRequired = parameterGroupType.Properties.Any(p => p.IsRequired);
//Create the new parameter object based on the parameter group type
Parameter parameterGroup = new Parameter()
{
Name = parameterGroupName,
IsRequired = isGroupParameterRequired,
Location = ClientModel.ParameterLocation.None,
SerializedName = string.Empty,
Type = parameterGroupType,
Documentation = "Additional parameters for the operation"
};
method.Parameters.Add(parameterGroup);
//Link the grouped parameters to their parent, and remove them from the method parameters
foreach (Property property in parameterGroups[parameterGroupName].Keys)
{
Parameter p = parameterGroups[parameterGroupName][property];
var parameterTransformation = new ParameterTransformation
{
OutputParameter = p
};
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = parameterGroup,
InputParameterProperty = property.GetClientName()
});
method.InputParameterTransformation.Add(parameterTransformation);
method.Parameters.Remove(p);
}
}
// Copy back flattening transformations if any
flatteningTransformations.ForEach(t => method.InputParameterTransformation.Add(t));
}
}
/// <summary>
/// Adds the parameter groups to operation parameters.
/// </summary>
/// <param name="serviceClient"></param>
public static void AddParameterGroups(ServiceClient serviceClient)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
HashSet <CompositeType> generatedParameterGroups = new HashSet <CompositeType>();
foreach (Method method in serviceClient.Methods)
{
//This group name is normalized by each languages code generator later, so it need not happen here.
Dictionary <string, Dictionary <Property, Parameter> > parameterGroups = new Dictionary <string, Dictionary <Property, Parameter> >();
foreach (Parameter parameter in method.Parameters)
{
if (parameter.Extensions.ContainsKey(ParameterGroupExtension))
{
Newtonsoft.Json.Linq.JContainer extensionObject = parameter.Extensions[ParameterGroupExtension] as Newtonsoft.Json.Linq.JContainer;
if (extensionObject != null)
{
string specifiedGroupName = extensionObject.Value <string>("name");
string parameterGroupName;
if (specifiedGroupName == null)
{
string postfix = extensionObject.Value <string>("postfix") ?? "Parameters";
parameterGroupName = method.Group + "-" + method.Name + "-" + postfix;
}
else
{
parameterGroupName = specifiedGroupName;
}
if (!parameterGroups.ContainsKey(parameterGroupName))
{
parameterGroups.Add(parameterGroupName, new Dictionary <Property, Parameter>());
}
Property groupProperty = new Property()
{
IsReadOnly = false, //Since these properties are used as parameters they are never read only
Name = parameter.Name,
IsRequired = parameter.IsRequired,
DefaultValue = parameter.DefaultValue,
//Constraints = parameter.Constraints, Omit these since we don't want to perform parameter validation
Documentation = parameter.Documentation,
Type = parameter.Type,
SerializedName = null //Parameter is never serialized directly
};
parameterGroups[parameterGroupName].Add(groupProperty, parameter);
}
}
}
foreach (string parameterGroupName in parameterGroups.Keys)
{
CompositeType parameterGroupType =
generatedParameterGroups.FirstOrDefault(item => item.Name == parameterGroupName);
bool createdNewCompositeType = false;
if (parameterGroupType == null)
{
parameterGroupType = new CompositeType()
{
Name = parameterGroupName,
Documentation = "Additional parameters for the " + method.Name + " operation."
};
generatedParameterGroups.Add(parameterGroupType);
//Populate the parameter group type with properties.
//Add to the service client
serviceClient.ModelTypes.Add(parameterGroupType);
createdNewCompositeType = true;
}
foreach (Property property in parameterGroups[parameterGroupName].Keys)
{
//Either the paramter group is "empty" since it is new, or it is "full" and we don't allow different schemas
if (createdNewCompositeType)
{
parameterGroupType.Properties.Add(property);
}
else
{
Property matchingProperty = parameterGroupType.Properties.FirstOrDefault(
item => item.Name == property.Name &&
item.IsReadOnly == property.IsReadOnly &&
item.DefaultValue == property.DefaultValue &&
item.SerializedName == property.SerializedName);
if (matchingProperty == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Property {0} was specified on group {1} but it is not on shared parameter group object {2}",
property.Name, method.Name, parameterGroupType.Name));
}
}
}
bool isGroupParameterRequired = parameterGroupType.Properties.Any(p => p.IsRequired);
//Create the new parameter object based on the parameter group type
Parameter parameterGroup = new Parameter()
{
Name = parameterGroupName,
IsRequired = isGroupParameterRequired,
Location = ClientModel.ParameterLocation.None,
SerializedName = string.Empty,
Type = parameterGroupType,
Documentation = "Additional parameters for the operation"
};
method.Parameters.Add(parameterGroup);
//Link the grouped parameters to their parent, and remove them from the method parameters
foreach (Property property in parameterGroups[parameterGroupName].Keys)
{
Parameter p = parameterGroups[parameterGroupName][property];
var parameterTransformation = new ParameterTransformation
{
OutputParameter = p
};
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = parameterGroup,
InputParameterProperty = property.Name
});
method.InputParameterTransformation.Add(parameterTransformation);
method.Parameters.Remove(p);
}
}
}
}
private static string BuildNullCheckExpression(ParameterTransformation transformation)
{
if (transformation == null)
{
throw new ArgumentNullException("transformation");
}
return string.Join(" or ",
transformation.ParameterMappings.Select(m =>
string.Format(CultureInfo.InvariantCulture,
"{0} is not None", m.InputParameter.Name)));
}
/// <summary>
/// Adds the parameter groups to operation parameters.
/// </summary>
/// <param name="codeModelient"></param>
public static void AddParameterGroups(CodeModel codeModel)
{
if (codeModel == null)
{
throw new ArgumentNullException("codeModel");
}
HashSet <CompositeType> generatedParameterGroups = new HashSet <CompositeType>();
foreach (Method method in codeModel.Methods)
{
//Copy out flattening transformations as they should be the last
List <ParameterTransformation> flatteningTransformations = method.InputParameterTransformation.ToList();
method.InputParameterTransformation.Clear();
//This group name is normalized by each languages code generator later, so it need not happen here.
IEnumerable <ParameterGroup> parameterGroups = ExtractParameterGroups(method);
List <Parameter> parametersToAddToMethod = new List <Parameter>();
List <Parameter> parametersToRemoveFromMethod = new List <Parameter>();
foreach (ParameterGroup parameterGroup in parameterGroups)
{
CompositeType parameterGroupType =
generatedParameterGroups.FirstOrDefault(item => item.Name.RawValue == parameterGroup.Name);
if (parameterGroupType == null)
{
IEnumerable <Method> methodsWhichUseGroup = GetMethodsUsingParameterGroup(codeModel.Methods, parameterGroup);
parameterGroupType = New <CompositeType>(parameterGroup.Name, new
{
Documentation = GenerateParameterGroupModelText(methodsWhichUseGroup)
});
generatedParameterGroups.Add(parameterGroupType);
//Add to the service client
codeModel.Add(parameterGroupType);
}
foreach (Property property in parameterGroup.ParameterMapping.Keys)
{
Property matchingProperty = parameterGroupType.Properties.FirstOrDefault(
item => item.Name.RawValue == property.Name.RawValue &&
item.IsReadOnly == property.IsReadOnly &&
item.DefaultValue.RawValue == property.DefaultValue.RawValue &&
item.SerializedName.RawValue == property.SerializedName.RawValue);
if (matchingProperty == null)
{
parameterGroupType.Add(property);
}
}
bool isGroupParameterRequired = parameterGroupType.Properties.Any(p => p.IsRequired);
//Create the new parameter object based on the parameter group type
Parameter newParameter = New <Parameter>(new
{
Name = parameterGroup.Name,
IsRequired = isGroupParameterRequired,
Location = ParameterLocation.None,
SerializedName = string.Empty,
ModelType = parameterGroupType,
Documentation = "Additional parameters for the operation"
});
parametersToAddToMethod.Add(newParameter);
//Link the grouped parameters to their parent, and remove them from the method parameters
foreach (Property property in parameterGroup.ParameterMapping.Keys)
{
Parameter p = parameterGroup.ParameterMapping[property];
var parameterTransformation = new ParameterTransformation
{
OutputParameter = p
};
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = newParameter,
InputParameterProperty = property.GetClientName()
});
method.InputParameterTransformation.Add(parameterTransformation);
parametersToRemoveFromMethod.Add(p);
}
}
method.Remove(p => parametersToRemoveFromMethod.Contains(p));
method.AddRange(parametersToAddToMethod);
// Copy back flattening transformations if any
flatteningTransformations.ForEach(t => method.InputParameterTransformation.Add(t));
}
}
/// <summary>
/// Adds the parameter groups to operation parameters.
/// </summary>
/// <param name="serviceClient"></param>
public static void AddParameterGroups(ServiceClient serviceClient)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
HashSet<CompositeType> generatedParameterGroups = new HashSet<CompositeType>();
foreach (Method method in serviceClient.Methods)
{
//Copy out flattening transformations as they should be the last
List<ParameterTransformation> flatteningTransformations = method.InputParameterTransformation.ToList();
method.InputParameterTransformation.Clear();
//This group name is normalized by each languages code generator later, so it need not happen here.
IEnumerable<ParameterGroup> parameterGroups = ExtractParameterGroups(method);
List<Parameter> parametersToAddToMethod = new List<Parameter>();
List<Parameter> parametersToRemoveFromMethod = new List<Parameter>();
foreach (ParameterGroup parameterGroup in parameterGroups)
{
CompositeType parameterGroupType =
generatedParameterGroups.FirstOrDefault(item => item.Name == parameterGroup.Name);
if (parameterGroupType == null)
{
IEnumerable<Method> methodsWhichUseGroup = GetMethodsUsingParameterGroup(serviceClient.Methods, parameterGroup);
parameterGroupType = new CompositeType
{
Name = parameterGroup.Name,
Documentation = GenerateParameterGroupModelText(methodsWhichUseGroup)
};
generatedParameterGroups.Add(parameterGroupType);
//Add to the service client
serviceClient.ModelTypes.Add(parameterGroupType);
}
foreach (Property property in parameterGroup.ParameterMapping.Keys)
{
Property matchingProperty = parameterGroupType.Properties.FirstOrDefault(
item => item.Name == property.Name &&
item.IsReadOnly == property.IsReadOnly &&
item.DefaultValue == property.DefaultValue &&
item.SerializedName == property.SerializedName);
if (matchingProperty == null)
{
parameterGroupType.Properties.Add(property);
}
}
bool isGroupParameterRequired = parameterGroupType.Properties.Any(p => p.IsRequired);
//Create the new parameter object based on the parameter group type
Parameter newParameter = new Parameter()
{
Name = parameterGroup.Name,
IsRequired = isGroupParameterRequired,
Location = ClientModel.ParameterLocation.None,
SerializedName = string.Empty,
Type = parameterGroupType,
Documentation = "Additional parameters for the operation"
};
parametersToAddToMethod.Add(newParameter);
//Link the grouped parameters to their parent, and remove them from the method parameters
foreach (Property property in parameterGroup.ParameterMapping.Keys)
{
Parameter p = parameterGroup.ParameterMapping[property];
var parameterTransformation = new ParameterTransformation
{
OutputParameter = p
};
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = newParameter,
InputParameterProperty = property.GetClientName()
});
method.InputParameterTransformation.Add(parameterTransformation);
parametersToRemoveFromMethod.Add(p);
}
}
method.Parameters.RemoveAll(p => parametersToRemoveFromMethod.Contains(p));
method.Parameters.AddRange(parametersToAddToMethod);
// Copy back flattening transformations if any
flatteningTransformations.ForEach(t => method.InputParameterTransformation.Add(t));
}
}
private static string BuildNullCheckExpression(ParameterTransformation transformation)
{
if (transformation == null)
{
throw new ArgumentNullException(nameof(transformation));
}
if (transformation.ParameterMappings.Count == 1)
{
return string.Format(CultureInfo.InvariantCulture,
"{0} !== null && {0} !== undefined",
transformation.ParameterMappings[0].InputParameter.Name);
}
else
{
return string.Join(" || ",
transformation.ParameterMappings.Select(m =>
string.Format(CultureInfo.InvariantCulture,
"({0} !== null && {0} !== undefined)", m.InputParameter.Name)));
}
}
/// <summary>
/// Flattens the request payload if the number of properties of the
/// payload is less than or equal to the PayloadFlatteningThreshold.
/// </summary>
/// <param name="codeModelient">Service client</param>
/// <param name="settings">AutoRest settings</param>
public static void FlattenMethodParameters(CodeModel codeModel)
{
if (codeModel == null)
{
throw new ArgumentNullException("codeModel");
}
foreach (var method in codeModel.Methods)
{
var bodyParameter = method.Parameters.FirstOrDefault(
p => p.Location == ParameterLocation.Body);
if (bodyParameter != null)
{
var bodyParameterType = bodyParameter.ModelType as CompositeType;
if (bodyParameterType != null &&
(bodyParameterType.ComposedProperties.Count(p => !p.IsConstant && !p.IsReadOnly) <= Settings.Instance.PayloadFlatteningThreshold ||
bodyParameter.ShouldBeFlattened()))
{
var parameterTransformation = new ParameterTransformation
{
OutputParameter = bodyParameter
};
method.InputParameterTransformation.Add(parameterTransformation);
method.Remove(bodyParameter);
foreach (var property in bodyParameterType.ComposedProperties.Where(p => !p.IsConstant && p.Name != null && !p.IsReadOnly))
{
var newMethodParameter = New<Parameter>();
newMethodParameter.LoadFrom(property);
var documentationString = !string.IsNullOrEmpty(property.Summary) ? property.Summary + " " : string.Empty;
documentationString += property.Documentation;
newMethodParameter.Documentation = documentationString;
bodyParameter.Extensions.ForEach(kv => { newMethodParameter.Extensions[kv.Key] = kv.Value; });
method.Add(newMethodParameter);
parameterTransformation.ParameterMappings.Add(new ParameterMapping
{
InputParameter = newMethodParameter,
OutputParameterProperty = property.GetClientName()
});
}
}
}
}
}
private static string BuildNullCheckExpression(ParameterTransformation transformation)
{
if (transformation == null)
{
throw new ArgumentNullException("transformation");
}
return string.Join(" || ",
transformation.ParameterMappings
.Where(m => m.InputParameter.IsNullable())
.Select(m => m.InputParameter.Name + " != null"));
}
