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")); }