/// <summary>Generates the parameter name for the given parameter.</summary>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <returns>The parameter name.</returns>
public string Generate(SwaggerParameter parameter, IEnumerable <SwaggerParameter> allParameters)
{
if (string.IsNullOrEmpty(parameter.Name))
{
return("unnamed");
}
var variableName = ConversionUtilities.ConvertToLowerCamelCase(parameter.Name
.Replace("-", "_")
.Replace(".", "_")
.Replace("$", string.Empty)
.Replace("[", string.Empty)
.Replace("]", string.Empty), true);
if (allParameters.Count(p => p.Name == parameter.Name) > 1)
{
variableName = variableName + parameter.Kind;
}
var key = $"{parameter.ParentOperation?.OperationId}.{variableName}";
if (!_knowParameters.ContainsKey(key))
{
_knowParameters.Add(key, 1);
}
else
{
variableName = $"{variableName}{_knowParameters[key]++}";
}
return(variableName);
}
internal virtual string GetParameterName(SwaggerParameter parameter)
{
return(parameter.Name
.Replace("-", "_")
.Replace(".", "_")
.Replace("$", string.Empty));
}
public static void OnBuildMethodParameter(Method method,
SwaggerParameter currentSwaggerParam,
string paramNameBuilder)
{
if (currentSwaggerParam == null)
{
throw new ArgumentNullException("currentSwaggerParam");
}
bool hasCollectionFormat = currentSwaggerParam.CollectionFormat != CollectionFormat.None;
if (currentSwaggerParam.Schema?.Type == DataType.Array && !hasCollectionFormat)
{
// If the parameter type is array default the collectionFormat to csv
currentSwaggerParam.Style = ParameterStyle.Form;
}
if (hasCollectionFormat && currentSwaggerParam.In == ParameterLocation.Path)
{
if (method?.Url == null)
{
throw new ArgumentNullException("method");
}
method.Url = method.Url.Replace(currentSwaggerParam.Name, paramNameBuilder);
}
}
private SwaggerParameter CreateBodyParameter(SwaggerService service, ParameterInfo parameter, ISchemaResolver schemaResolver)
{
var isRequired = IsParameterRequired(parameter);
var operationParameter = new SwaggerParameter
{
Name = parameter.Name,
Kind = SwaggerParameterKind.Body,
IsRequired = isRequired,
Schema = CreateAndAddSchema(service, parameter.ParameterType, !isRequired, parameter.GetCustomAttributes(), schemaResolver)
};
var typeDescription = JsonObjectTypeDescription.FromType(parameter.ParameterType, parameter.GetCustomAttributes(), Settings.DefaultEnumHandling);
operationParameter.IsNullableRaw = typeDescription.IsNullable;
var description = parameter.GetXmlDocumentation();
if (description != string.Empty)
{
operationParameter.Description = description;
}
return(operationParameter);
}
private async Task <SwaggerParameter> AddBodyParameterAsync(OperationProcessorContext context, ExtendedApiParameterDescription extendedApiParameter)
{
SwaggerParameter operationParameter;
var operation = context.OperationDescription.Operation;
var parameterType = extendedApiParameter.ParameterType;
if (parameterType.Name == "XmlDocument" || parameterType.InheritsFrom("XmlDocument", TypeNameStyle.Name))
{
operation.Consumes = new List <string> {
"application/xml"
};
operationParameter = new SwaggerParameter
{
Name = extendedApiParameter.ApiParameter.Name,
Kind = SwaggerParameterKind.Body,
Schema = new JsonSchema4 {
Type = JsonObjectType.String
},
IsNullableRaw = true,
IsRequired = extendedApiParameter.IsRequired(_settings.RequireParametersWithoutDefault),
Description = await extendedApiParameter.GetDocumentationAsync().ConfigureAwait(false)
};
}
else if (parameterType.IsAssignableTo("System.IO.Stream", TypeNameStyle.FullName))
{
operation.Consumes = new List <string> {
"application/octet-stream"
};
operationParameter = new SwaggerParameter
{
Name = extendedApiParameter.ApiParameter.Name,
Kind = SwaggerParameterKind.Body,
Schema = new JsonSchema4 {
Type = JsonObjectType.String, Format = JsonFormatStrings.Byte
},
IsNullableRaw = true,
IsRequired = extendedApiParameter.IsRequired(_settings.RequireParametersWithoutDefault),
Description = await extendedApiParameter.GetDocumentationAsync().ConfigureAwait(false)
};
}
else
{
var typeDescription = _settings.ReflectionService.GetDescription(extendedApiParameter.ParameterType, extendedApiParameter.Attributes, _settings);
operationParameter = new SwaggerParameter
{
Name = extendedApiParameter.ApiParameter.Name,
Kind = SwaggerParameterKind.Body,
IsRequired = extendedApiParameter.IsRequired(_settings.RequireParametersWithoutDefault),
IsNullableRaw = typeDescription.IsNullable,
Description = await extendedApiParameter.GetDocumentationAsync().ConfigureAwait(false),
Schema = await context.SchemaGenerator.GenerateWithReferenceAndNullabilityAsync <JsonSchema4>(
extendedApiParameter.ParameterType, extendedApiParameter.Attributes, isNullable : false, schemaResolver : context.SchemaResolver).ConfigureAwait(false)
};
}
operation.Parameters.Add(operationParameter);
return(operationParameter);
}
public static StringBuilder OnBuildMethodParameter(Method method,
SwaggerParameter currentSwaggerParam,
StringBuilder paramNameBuilder)
{
if (currentSwaggerParam == null)
{
throw new ArgumentNullException("currentSwaggerParam");
}
bool hasCollectionFormat = currentSwaggerParam.CollectionFormat != CollectionFormat.None;
if (currentSwaggerParam.Type == DataType.Array && !hasCollectionFormat)
{
// If the parameter type is array default the collectionFormat to csv
currentSwaggerParam.CollectionFormat = CollectionFormat.Csv;
}
if (hasCollectionFormat)
{
if (currentSwaggerParam.In == ParameterLocation.Path)
{
if (method == null || method.Url == null)
{
throw new ArgumentNullException("method");
}
method.Url = ((string)method.Url).Replace(
string.Format(CultureInfo.InvariantCulture, "{0}", currentSwaggerParam.Name),
string.Format(CultureInfo.InvariantCulture, "{0}", paramNameBuilder));
}
}
return(paramNameBuilder);
}
private SwaggerParameter CreatePrimitiveParameter(SwaggerService service, string name, string description,
Type type, IList <Attribute> parentAttributes, ISchemaResolver schemaResolver)
{
var schemaDefinitionAppender = new SwaggerServiceSchemaDefinitionAppender(service, Settings.TypeNameGenerator);
var schemaGenerator = new RootTypeJsonSchemaGenerator(service, schemaDefinitionAppender, Settings);
var typeDescription = JsonObjectTypeDescription.FromType(type, parentAttributes, Settings.DefaultEnumHandling);
var parameterType = typeDescription.IsComplexType ? typeof(string) : type; // complex types must be treated as string
var operationParameter = new SwaggerParameter();
typeDescription.ApplyType(operationParameter);
if (parameterType.GetTypeInfo().IsEnum)
{
operationParameter.SchemaReference = schemaGenerator.Generate <JsonSchema4>(parameterType, null, parentAttributes, schemaDefinitionAppender, schemaResolver);
}
else
{
schemaGenerator.ApplyPropertyAnnotations(operationParameter, type, parentAttributes, typeDescription);
}
operationParameter.Name = name;
operationParameter.IsRequired = parentAttributes?.Any(a => a.GetType().Name == "RequiredAttribute") ?? false;
operationParameter.IsNullableRaw = typeDescription.IsNullable;
if (description != string.Empty)
{
operationParameter.Description = description;
}
return(operationParameter);
}
private void HandleAsObjectParameters(SwaggerOperation operation, DotvvmCSharpOperationModel model, ClientGeneratorBaseSettings settings)
{
// find groups of parameters that should be treated as one
var parameters = model.QueryParameters.Where(p => p.Name.Contains(".") && p.Schema.ExtensionData.ContainsKey("x-dotvvm-wrapperType"));
var groups = parameters.GroupBy(p => p.Name.Substring(0, p.Name.IndexOf("."))).ToList();
foreach (var g in groups)
{
var typeName = g.First().Schema.ExtensionData["x-dotvvm-wrapperType"].ToString();
typeName = typeName.Substring(0, typeName.IndexOf(","));
var swaggerParameter = new SwaggerParameter()
{
Name = g.Key,
Schema = new JsonSchema4(),
Kind = SwaggerParameterKind.Query
};
var newParameter = new DotvvmCSharpParameterModel(g.Key, g.Key, typeName, swaggerParameter, operation.Parameters, settings.CodeGeneratorSettings, this, model)
{
ExcludeFromQuery = true
};
var targetIndex = g.Min(p => model.Parameters.IndexOf(p));
foreach (var p in g)
{
((DotvvmCSharpParameterModel)p).CustomInitializer = $"var {p.VariableName} = {g.Key} != null ? {p.Name} : default({p.Type});";
}
model.Parameters.Insert(targetIndex, newParameter);
}
}
/// <summary>Initializes a new instance of the <see cref="ParameterModel" /> class.</summary>
/// <param name="typeName">The type name.</param>
/// <param name="operation">The operation.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="settings">The settings.</param>
public ParameterModel(string typeName, SwaggerOperation operation, SwaggerParameter parameter, CodeGeneratorSettingsBase settings)
{
Type = typeName;
_operation = operation;
_parameter = parameter;
_settings = settings;
}
/// <summary>Creates a path parameter for a given type.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="parameterType">Type of the parameter.</param>
/// <returns>The parameter.</returns>
public SwaggerParameter CreateUntypedPathParameter(string parameterName, string parameterType)
{
var parameter = new SwaggerParameter();
parameter.Name = parameterName;
parameter.Kind = SwaggerParameterKind.Path;
parameter.IsRequired = true;
if (_settings.SchemaType == SchemaType.Swagger2)
{
parameter.IsNullableRaw = false;
}
if (parameterType == "guid")
{
parameter.Type = JsonObjectType.String;
parameter.Format = JsonFormatStrings.Guid;
}
else if (parameterType == "int" || parameterType == "integer" || parameterType == "short" || parameterType == "long")
{
parameter.Type = JsonObjectType.Integer;
}
else if (parameterType == "number" || parameterType == "decimal" || parameterType == "double")
{
parameter.Type = JsonObjectType.Number;
}
else
{
parameter.Type = JsonObjectType.String;
}
return(parameter);
}
internal virtual string GetParameterVariableName(SwaggerParameter parameter)
{
return(ConversionUtilities.ConvertToLowerCamelCase(parameter.Name
.Replace("-", "_")
.Replace(".", "_")
.Replace("$", string.Empty), true));
}
private void ValidateBody(HttpContext context, SwaggerParameter param, List <SwaggerParameterError> errors)
{
var body = ReadBody(context.Request.Body);
if (param.IsRequired && string.IsNullOrEmpty(body))
{
errors.Add(new SwaggerParameterError
{
Message = $"Missing required parameter {param.Name}",
});
}
if (!string.IsNullOrEmpty(body))
{
param.Schema.AllowAdditionalProperties = false;
param.ActualSchema.AllowAdditionalProperties = false;
var validationErrors = param.Schema.Validate(body);
if (validationErrors.Any())
{
errors.AddRange(validationErrors.Select(x => new SwaggerParameterError
{
Message = x.ToString(),
}));
}
}
}
public static SwaggerArgument FromParameter(SwaggerParameter param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.Type == JsonObjectType.Boolean)
{
return(new BoolArgument(param));
}
if (param.Format == "date-time")
{
return(new DateTimeArgument(param));
}
if (param.ActualSchema.IsEnumeration)
{
return(new EnumArgument(param));
}
if (param.Type == JsonObjectType.File)
{
return(new FileArgument(param));
}
return(new StringArgument(param));
}
public static void PopulateParameter(IVariable parameter, SwaggerParameter swaggerObject)
{
if (swaggerObject == null)
{
throw new ArgumentNullException("swaggerObject");
}
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
parameter.IsRequired = swaggerObject.IsRequired;
parameter.DefaultValue = swaggerObject.Schema?.Default;
if (IsSwaggerObjectConstant(swaggerObject.Schema, parameter.IsRequired))
{
parameter.DefaultValue = swaggerObject.Schema.Enum.TokensToStrings().First();
parameter.IsConstant = true;
}
parameter.Documentation = swaggerObject.Description;
parameter.CollectionFormat = swaggerObject.CollectionFormat;
// tag the paramter with all the extensions from the swagger object
parameter.Extensions.AddRange(swaggerObject.Extensions);
SetConstraints(parameter.Constraints, swaggerObject.Schema);
}
private SwaggerParameter CreatePrimitiveParameter(string name, string description, Type type, IList <Attribute> parentAttributes,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var typeDescription = JsonObjectTypeDescription.FromType(type, parentAttributes, Settings.DefaultEnumHandling);
SwaggerParameter operationParameter;
if (typeDescription.IsEnum)
{
// TODO(incompatibility): We use "schema" even it is not allowed in non-body parameters
var parameterType = type.Name == "Nullable`1" ? type.GetGenericTypeArguments().Single() : type;
operationParameter = new SwaggerParameter
{
Type = typeDescription.Type, // Used as fallback for generators which do not check the "schema" property
Schema = _schemaGenerator.Generate <JsonSchema4>(parameterType, parentAttributes, schemaResolver, schemaDefinitionAppender)
};
}
else
{
var parameterType = typeDescription.Type.HasFlag(JsonObjectType.Object) ? typeof(string) : type; // object types must be treated as string
operationParameter = _schemaGenerator.Generate <SwaggerParameter>(parameterType, parentAttributes, schemaResolver, schemaDefinitionAppender);
_schemaGenerator.ApplyPropertyAnnotations(operationParameter, type, parentAttributes, typeDescription);
}
operationParameter.Name = name;
operationParameter.IsRequired = parentAttributes?.Any(a => a.GetType().Name == "RequiredAttribute") ?? false;
operationParameter.IsNullableRaw = typeDescription.IsNullable;
if (description != string.Empty)
{
operationParameter.Description = description;
}
return(operationParameter);
}
internal virtual string GetParameterVariableName(SwaggerParameter parameter)
{
return ConversionUtilities.ConvertToLowerCamelCase(parameter.Name
.Replace("-", "_")
.Replace(".", "_")
.Replace("$", string.Empty), true);
}
private void HandleAsObjectParameters(SwaggerOperation operation, DotvvmTypeScriptOperationModel model, SwaggerToTypeScriptClientGeneratorSettings settings)
{
// find groups of parameters that should be treated as one
var parameters = model.QueryParameters.Where(p => p.Name.Contains('.') && p.Schema.ExtensionData.ContainsKey(ApiConstants.DotvvmWrapperTypeKey));
var groups = parameters.GroupBy(p => p.Name.Substring(0, p.Name.IndexOf('.'))).ToList();
foreach (var group in groups)
{
var swaggerParameter = new SwaggerParameter()
{
Name = group.Key,
Schema = new JsonSchema4(),
Kind = SwaggerParameterKind.Query
};
var newParameter = new DotvvmTypeScriptParameterModel(group.Key, group.Key, "any", swaggerParameter, operation.Parameters, settings, this, model)
{
ExcludeFromQuery = true
};
var targetIndex = group.Min(p => model.Parameters.IndexOf(p));
foreach (var p in group)
{
((DotvvmTypeScriptParameterModel)p).CustomInitializer = $"let {p.VariableName} = ({group.Key} !== null && typeof {group.Key} === 'object') ? {p.Name} : null;";
}
model.Parameters.Insert(targetIndex, newParameter);
}
}
public SwaggerParameter Unwrap(SwaggerParameter swaggerParameter)
{
if (swaggerParameter == null)
{
throw new ArgumentNullException("swaggerParameter");
}
// If referencing global parameters serializationProperty
if (swaggerParameter.Reference != null)
{
string referenceKey = swaggerParameter.Reference.StripParameterPath();
if (!ServiceDefinition.Parameters.ContainsKey(referenceKey))
{
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture,
Resources.DefinitionDoesNotExist, referenceKey));
}
swaggerParameter = ServiceDefinition.Parameters[referenceKey];
}
// Unwrap the schema if in "body"
if (swaggerParameter.Schema != null && swaggerParameter.In == ParameterLocation.Body)
{
swaggerParameter.Schema = Resolver.Unwrap(swaggerParameter.Schema);
}
return(swaggerParameter);
}
private async Task AddBodyParameterAsync(OperationProcessorContext context, string name, ParameterInfo parameter)
{
var operation = context.OperationDescription.Operation;
if (parameter.ParameterType.Name == "XmlDocument" || parameter.ParameterType.InheritsFrom("XmlDocument", TypeNameStyle.Name))
{
operation.Consumes = new List <string> {
"application/xml"
};
operation.Parameters.Add(new SwaggerParameter
{
Name = name,
Kind = SwaggerParameterKind.Body,
Schema = new JsonSchema4 {
Type = JsonObjectType.String
},
IsNullableRaw = true,
IsRequired = parameter.HasDefaultValue == false,
Description = await parameter.GetDescriptionAsync(parameter.GetCustomAttributes()).ConfigureAwait(false)
});
}
else if (parameter.ParameterType.IsAssignableTo("System.IO.Stream", TypeNameStyle.FullName))
{
operation.Consumes = new List <string> {
"application/octet-stream"
};
operation.Parameters.Add(new SwaggerParameter
{
Name = name,
Kind = SwaggerParameterKind.Body,
Schema = new JsonSchema4 {
Type = JsonObjectType.String, Format = JsonFormatStrings.Byte
},
IsNullableRaw = true,
IsRequired = parameter.HasDefaultValue == false,
Description = await parameter.GetDescriptionAsync(parameter.GetCustomAttributes()).ConfigureAwait(false)
});
}
else
{
var attributes = parameter.GetCustomAttributes();
var typeDescription = _settings.ReflectionService.GetDescription(parameter.ParameterType, attributes, _settings);
var operationParameter = new SwaggerParameter
{
Name = name,
Kind = SwaggerParameterKind.Body,
IsRequired = true, // FromBody parameters are always required
IsNullableRaw = typeDescription.IsNullable,
Description = await parameter.GetDescriptionAsync(attributes).ConfigureAwait(false),
Schema = await context.SchemaGenerator.GenerateWithReferenceAndNullabilityAsync <JsonSchema4>(
parameter.ParameterType, parameter.GetCustomAttributes(), isNullable : false, schemaResolver : context.SchemaResolver).ConfigureAwait(false)
};
operation.Parameters.Add(operationParameter);
}
}
private SwaggerParameter CreateBodyParameter(ParameterInfo parameter, ISchemaResolver schemaResolver)
{
var operationParameter = new SwaggerParameter();
operationParameter.Schema = CreateAndAddSchema <SwaggerParameter>(parameter.ParameterType, schemaResolver);
operationParameter.Name = "request";
operationParameter.Kind = SwaggerParameterKind.body;
return(operationParameter);
}
private void InitializeFileParameter(SwaggerParameter operationParameter, bool isFileArray)
{
operationParameter.Type = JsonObjectType.File;
operationParameter.Kind = SwaggerParameterKind.FormData;
if (isFileArray)
{
operationParameter.CollectionFormat = SwaggerParameterCollectionFormat.Multi;
}
}
/// <summary>Initializes a new instance of the <see cref="ParameterModel" /> class.</summary>
/// <param name="typeName">The type name.</param>
/// <param name="operation">The operation.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="settings">The settings.</param>
/// <param name="clientGeneratorBase">The client generator base.</param>
public ParameterModel(string typeName, SwaggerOperation operation, SwaggerParameter parameter,
string parameterName, CodeGeneratorSettingsBase settings, ClientGeneratorBase clientGeneratorBase)
{
Type = typeName;
Name = parameterName;
_operation = operation;
_parameter = parameter;
_settings = settings;
_clientGeneratorBase = clientGeneratorBase;
}
private bool IsValidArray(SwaggerParameter parameter, string value)
{
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Csv)
{
var jsonify = $@"[""{string.Join(@""",""", value.Split(','))}""]";
var schemaErrors = parameter.Validate(jsonify);
return(schemaErrors.Count == 0);
}
throw new NotImplementedException();
}
/// <summary>Creates a primitive parameter for the given parameter information reflection object.</summary>
/// <param name="name">The name.</param>
/// <param name="description">The description.</param>
/// <param name="parameterType">Type of the parameter.</param>
/// <param name="parentAttributes">The parent attributes.</param>
/// <returns></returns>
public async Task <SwaggerParameter> CreatePrimitiveParameterAsync(string name, string description, Type parameterType, IList <Attribute> parentAttributes)
{
var typeDescription = JsonObjectTypeDescription.FromType(parameterType, ResolveContract(parameterType), parentAttributes, _settings.DefaultEnumHandling);
SwaggerParameter operationParameter;
if (typeDescription.IsEnum)
{
// TODO(incompatibility): We use "schema" even it is not allowed in non-body parameters
parameterType = parameterType.Name == "Nullable`1" ? parameterType.GetGenericTypeArguments().Single() : parameterType;
operationParameter = new SwaggerParameter
{
Type = typeDescription.Type, // Used as fallback for generators which do not check the "schema" property
Schema = new JsonSchema4
{
SchemaReference = await _schemaGenerator.GenerateAsync(parameterType, parentAttributes, _schemaResolver).ConfigureAwait(false)
}
};
}
else
{
var hasTypeMapper = _settings.TypeMappers.Any(tm => tm.MappedType == parameterType);
if (!hasTypeMapper)
{
parameterType = typeDescription.Type.HasFlag(JsonObjectType.Object) ? typeof(string) : parameterType; // object types must be treated as string
}
operationParameter = await _schemaGenerator.GenerateAsync <SwaggerParameter>(parameterType, parentAttributes, _schemaResolver).ConfigureAwait(false);
_schemaGenerator.ApplyPropertyAnnotations(operationParameter, new Newtonsoft.Json.Serialization.JsonProperty(), parameterType, parentAttributes, typeDescription);
// check if the type mapper did not properly change the type to a primitive
if (hasTypeMapper && typeDescription.Type.HasFlag(JsonObjectType.Object) && operationParameter.Type == JsonObjectType.Object)
{
operationParameter.Type = JsonObjectType.String; // enforce string as default
}
}
operationParameter.Name = name;
operationParameter.IsRequired = parentAttributes?.Any(a => a.GetType().Name == "RequiredAttribute") ?? false;
operationParameter.IsNullableRaw = typeDescription.IsNullable;
if (typeDescription.Type.HasFlag(JsonObjectType.Array))
{
operationParameter.CollectionFormat = SwaggerParameterCollectionFormat.Multi;
}
if (description != string.Empty)
{
operationParameter.Description = description;
}
return(operationParameter);
}
/// <summary>Initializes a new instance of the <see cref="ParameterModel" /> class.</summary>
/// <param name="typeName">The type name.</param>
/// <param name="operation">The operation.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="settings">The settings.</param>
/// <param name="clientGeneratorBase">The client generator base.</param>
public ParameterModel(string typeName, SwaggerOperation operation, SwaggerParameter parameter,
string parameterName, string variableName, CodeGeneratorSettingsBase settings, ClientGeneratorBase clientGeneratorBase)
{
Type = typeName;
Name = parameterName;
VariableName = variableName;
_operation = operation;
_parameter = parameter;
_settings = settings;
_clientGeneratorBase = clientGeneratorBase;
}
/// <summary>Initializes a new instance of the <see cref="CSharpParameterModel" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
public CSharpParameterModel(
string parameterName,
string variableName,
string typeName,
SwaggerParameter parameter,
IList <SwaggerParameter> allParameters,
CodeGeneratorSettingsBase settings,
IClientGenerator generator,
TypeResolverBase typeResolver)
: base(parameterName, variableName, typeName, parameter, allParameters, settings, generator, typeResolver)
{
}
/// <summary>Initializes a new instance of the <see cref="ParameterModelBase" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
protected ParameterModelBase(string parameterName, string variableName, string typeName,
SwaggerParameter parameter, IList <SwaggerParameter> allParameters, CodeGeneratorSettingsBase settings, IClientGenerator generator)
{
Type = typeName;
Name = parameterName;
VariableName = variableName;
_allParameters = allParameters;
_parameter = parameter;
_settings = settings;
_generator = generator;
}
public Parameter Build()
{
string parameterName = _swaggerParameter.Name;
SwaggerParameter unwrappedParameter = _swaggerParameter;
if (_swaggerParameter.Reference != null)
{
unwrappedParameter = Modeler.Unwrap(_swaggerParameter);
}
if (unwrappedParameter.Schema != null && unwrappedParameter.Schema.Reference != null)
{
parameterName = unwrappedParameter.Schema.Reference.StripComponentsSchemaPath();
}
if (parameterName == null)
{
parameterName = unwrappedParameter.Name;
}
var isRequired = unwrappedParameter.IsRequired || unwrappedParameter.In == AutoRest.Modeler.Model.ParameterLocation.Path;
unwrappedParameter.IsRequired = isRequired;
if (unwrappedParameter.Extensions.ContainsKey("x-ms-enum") && !unwrappedParameter.Schema.Extensions.ContainsKey("x-ms-enum"))
{
unwrappedParameter.Schema.Extensions["x-ms-enum"] = unwrappedParameter.Extensions["x-ms-enum"];
}
IModelType parameterType = BuildServiceType(parameterName, isRequired);
var parameter = New <Parameter>(new
{
Name = unwrappedParameter.Name,
SerializedName = unwrappedParameter.Name,
ModelType = parameterType,
Location = (Core.Model.ParameterLocation)Enum.Parse(typeof(Core.Model.ParameterLocation), unwrappedParameter.In.ToString())
});
// translate allowReserved back to what "code-model-v1"-gen generators expect
if (unwrappedParameter.AllowReserved.HasValue && !parameter.Extensions.ContainsKey("x-ms-skip-url-encoding"))
{
parameter.Extensions["x-ms-skip-url-encoding"] = unwrappedParameter.AllowReserved.Value;
}
PopulateParameter(parameter, unwrappedParameter);
parameter.DeprecationMessage = unwrappedParameter.GetDeprecationMessage(EntityType.Parameter);
if (_swaggerParameter.Reference != null)
{
var clientProperty = Modeler.CodeModel.Properties.FirstOrDefault(p => p.SerializedName == unwrappedParameter.Name);
parameter.ClientProperty = clientProperty;
}
return(parameter);
}
/// <summary>Resolves the type of the parameter.</summary>
/// <param name="parameter">The parameter.</param>
/// <returns>The parameter type name.</returns>
protected override string ResolveParameterType(SwaggerParameter parameter)
{
var schema = parameter.ActualSchema;
if (schema.Type == JsonObjectType.File)
{
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Multi && !schema.Type.HasFlag(JsonObjectType.Array))
return "FileParameter[]";
return "FileParameter";
}
return base.ResolveParameterType(parameter);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptParameterModel" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
public TypeScriptParameterModel(
string parameterName,
string variableName,
string typeName,
SwaggerParameter parameter,
IList <SwaggerParameter> allParameters,
SwaggerToTypeScriptClientGeneratorSettings settings,
SwaggerToTypeScriptClientGenerator generator,
TypeResolverBase typeResolver)
: base(parameterName, variableName, typeName, parameter, allParameters, settings.TypeScriptGeneratorSettings, generator, typeResolver)
{
_settings = settings;
}
public static void AddQueryParameter(this SwaggerOperation operation, string name, JsonObjectType type, string description = null)
{
var parameter = new SwaggerParameter {
Type = type, Name = name, Kind = SwaggerParameterKind.Query
};
if (!string.IsNullOrWhiteSpace(description))
{
parameter.Description = description;
}
operation.Parameters.Add(parameter);
}
/// <summary>Gets the name of the parameter variable.</summary>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <returns>The parameter variable name.</returns>
protected virtual string GetParameterVariableName(SwaggerParameter parameter, IEnumerable <SwaggerParameter> allParameters)
{
var variableName = ConversionUtilities.ConvertToLowerCamelCase(parameter.Name
.Replace("-", "_")
.Replace(".", "_")
.Replace("$", string.Empty), true);
if (allParameters.Count(p => p.Name == parameter.Name) > 1)
{
return(variableName + parameter.Kind);
}
return(variableName);
}
private bool UrlValidType(SwaggerParameter param, object value)
{
try
{
switch (param.Type)
{
case JsonObjectType.None:
break;
case JsonObjectType.Array:
return(IsValidArray(param, value.ToString()));
case JsonObjectType.Boolean:
var valb = Convert.ToBoolean(value);
break;
case JsonObjectType.Integer:
var vali = Convert.ToInt32(value);
break;
case JsonObjectType.Null:
return(value == null);
case JsonObjectType.Number:
var valn = Convert.ToDouble(value);
break;
case JsonObjectType.Object:
return(value != null);
case JsonObjectType.String:
var vals = Convert.ToString(value);
break;
case JsonObjectType.File:
// TODO How do we handle this
break;
default:
throw new ArgumentOutOfRangeException(nameof(param.Type), param.Type, null);
}
}
catch (FormatException)
{
return(false);
}
return(true);
}
/// <summary>Resolves the type of the parameter.</summary>
/// <param name="parameter">The parameter.</param>
/// <returns>The parameter type name.</returns>
protected override string ResolveParameterType(SwaggerParameter parameter)
{
var schema = parameter.ActualSchema;
if (schema.Type == JsonObjectType.File)
{
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Multi && !schema.Type.HasFlag(JsonObjectType.Array))
return "System.Collections.Generic.IEnumerable<FileParameter>";
return "FileParameter";
}
return base.ResolveParameterType(parameter)
.Replace(Settings.CSharpGeneratorSettings.ArrayType + "<", "System.Collections.Generic.IEnumerable<")
.Replace(Settings.CSharpGeneratorSettings.DictionaryType + "<", "System.Collections.Generic.IDictionary<");
}
/// <summary>Creates a path parameter for a given type.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="parameterType">Type of the parameter.</param>
/// <returns>The parameter.</returns>
public SwaggerParameter CreatePathParameter(string parameterName, string parameterType)
{
var parameter = new SwaggerParameter();
parameter.Name = parameterName;
parameter.Kind = SwaggerParameterKind.Path;
parameter.IsRequired = true;
parameter.IsNullableRaw = false;
if (parameterType == "guid")
{
parameter.Type = JsonObjectType.String;
parameter.Format = JsonFormatStrings.Guid;
}
else if (parameterType == "int" || parameterType == "integer" || parameterType == "short" || parameterType == "long")
parameter.Type = JsonObjectType.Integer;
else if (parameterType == "number" || parameterType == "decimal" || parameterType == "double")
parameter.Type = JsonObjectType.Number;
else
parameter.Type = JsonObjectType.String;
return parameter;
}
internal override string GetParameterVariableName(SwaggerParameter parameter)
{
var name = base.GetParameterVariableName(parameter);
return ReservedKeywords.Contains(name) ? "@" + name : name;
}
private void InitializeFileParameter(SwaggerParameter operationParameter, bool isFileArray)
{
operationParameter.Type = JsonObjectType.File;
operationParameter.Kind = SwaggerParameterKind.FormData;
if (isFileArray)
operationParameter.CollectionFormat = SwaggerParameterCollectionFormat.Multi;
}
/// <summary>Creates a primitive parameter for the given parameter information reflection object.</summary>
/// <param name="name">The name.</param>
/// <param name="parameter">The parameter.</param>
/// <returns></returns>
public SwaggerParameter CreateBodyParameter(string name, ParameterInfo parameter)
{
var isRequired = IsParameterRequired(parameter);
var typeDescription = JsonObjectTypeDescription.FromType(parameter.ParameterType, parameter.GetCustomAttributes(), _settings.DefaultEnumHandling);
var operationParameter = new SwaggerParameter
{
Name = name,
Kind = SwaggerParameterKind.Body,
IsRequired = isRequired,
IsNullableRaw = typeDescription.IsNullable,
Schema = GenerateAndAppendSchemaFromType(parameter.ParameterType, !isRequired, parameter.GetCustomAttributes()),
};
var description = parameter.GetXmlDocumentation();
if (description != string.Empty)
operationParameter.Description = description;
return operationParameter;
}
/// <summary>Creates a primitive parameter for the given parameter information reflection object.</summary>
/// <param name="name">The name.</param>
/// <param name="description">The description.</param>
/// <param name="parameterType">Type of the parameter.</param>
/// <param name="parentAttributes">The parent attributes.</param>
/// <returns></returns>
public SwaggerParameter CreatePrimitiveParameter(string name, string description, Type parameterType, IList<Attribute> parentAttributes)
{
var typeDescription = JsonObjectTypeDescription.FromType(parameterType, parentAttributes, _settings.DefaultEnumHandling);
SwaggerParameter operationParameter;
if (typeDescription.IsEnum)
{
// TODO(incompatibility): We use "schema" even it is not allowed in non-body parameters
parameterType = parameterType.Name == "Nullable`1" ? parameterType.GetGenericTypeArguments().Single() : parameterType;
operationParameter = new SwaggerParameter
{
Type = typeDescription.Type, // Used as fallback for generators which do not check the "schema" property
Schema = new JsonSchema4
{
SchemaReference = _schemaGenerator.Generate<JsonSchema4>(parameterType, parentAttributes, _schemaResolver)
}
};
}
else
{
parameterType = typeDescription.Type.HasFlag(JsonObjectType.Object) ? typeof(string) : parameterType; // object types must be treated as string
operationParameter = _schemaGenerator.Generate<SwaggerParameter>(parameterType, parentAttributes, _schemaResolver);
_schemaGenerator.ApplyPropertyAnnotations(operationParameter, parameterType, parentAttributes, typeDescription);
}
operationParameter.Name = name;
operationParameter.IsRequired = parentAttributes?.Any(a => a.GetType().Name == "RequiredAttribute") ?? false;
operationParameter.IsNullableRaw = typeDescription.IsNullable;
if (description != string.Empty)
operationParameter.Description = description;
return operationParameter;
}
/// <summary>Resolves the type of the parameter.</summary>
/// <param name="parameter">The parameter.</param>
/// <returns>The parameter type name.</returns>
protected virtual string ResolveParameterType(SwaggerParameter parameter)
{
var schema = parameter.ActualSchema;
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Multi && !schema.Type.HasFlag(JsonObjectType.Array))
schema = new JsonSchema4 { Type = JsonObjectType.Array, Item = schema };
var typeNameHint = ConversionUtilities.ConvertToUpperCamelCase(parameter.Name, true);
return Resolver.Resolve(schema, parameter.IsRequired == false || parameter.IsNullable(BaseSettings.CodeGeneratorSettings.NullHandling), typeNameHint);
}
