public ComponentsToTypesBase(Settings settings, CodeCompileUnit codeCompileUnit, CodeNamespace clientNamespace)
{
this.codeCompileUnit = codeCompileUnit;
this.settings = settings;
this.ClientNamespace = clientNamespace;
TypeAliasDic = new TypeAliasDic();
}
public override void AddTypeToCodeDom(KeyValuePair <string, OpenApiSchema> item)
{
var ns = NameFunc.GetNamespaceOfClassName(item.Key);
var currentTypeName = NameFunc.RefineTypeName(item.Key, ns);
RegisterSchemaRefIdToBeAdded(item.Key);
OpenApiSchema schema = item.Value;
string type = schema.Type;
IList <OpenApiSchema> allOfBaseTypeSchemaList = schema.AllOf; //maybe empty
IList <IOpenApiAny> enumTypeList = schema.Enum; //maybe empty
bool isForClass = enumTypeList.Count == 0;
CodeTypeDeclaration typeDeclaration = null;
if (isForClass)
{
if (schema.Properties.Count > 0 || (schema.Properties.Count == 0 && allOfBaseTypeSchemaList.Count > 1))
{
typeDeclaration = AddTypeToClassNamespace(currentTypeName, ns);
if (String.IsNullOrEmpty(type) && allOfBaseTypeSchemaList.Count > 0)
{
OpenApiSchema allOfRef = allOfBaseTypeSchemaList[0];
if (allOfRef.Reference == null)
{
Trace.TraceWarning($"Not yet support Type {item.Key} having allOf[0] without Reference. Skipped.");
RemoveRegisteredSchemaRefId(item.Key);
return;
}
string baseTypeName = NameFunc.RefineTypeName(allOfRef.Reference.Id, ns); //pointing to parent class
typeDeclaration.BaseTypes.Add(baseTypeName);
if (allOfBaseTypeSchemaList.Count > 1)
{
OpenApiSchema allOfProperteisSchema = allOfBaseTypeSchemaList[1]; //the 2nd one points to properties of the derived type, while the 1st one points to the base type.
AddProperties(typeDeclaration, allOfProperteisSchema, currentTypeName, ns);
}
}
CreateTypeDocComment(item, typeDeclaration);
AddProperties(typeDeclaration, schema, currentTypeName, ns);
}
else if (type == "array") // wrapper of array
{
OpenApiReference itemsRef = schema.Items.Reference;
if (itemsRef == null) //Array type with casual schema
{
if (schema.Items.Properties.Count > 0) //casual member type definition in an array type
{
var newTypeName = currentTypeName + "Element";
if (FindTypeDeclarationInNamespaces(newTypeName, ns) == null)
{
AddTypeToCodeDom(new KeyValuePair <string, OpenApiSchema>(newTypeName, schema.Items)); //so add casual type recursively
TypeAliasDic.Add(item.Key, $"{newTypeName}[]");
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {newTypeName}[]) -- generated: {newTypeName}");
}
}
else
{
RemoveRegisteredSchemaRefId(item.Key);
Trace.TraceWarning($"Not yet support array type with casual items type without reference and without casual properties: {item.Key}. Skipped.");
}
return;
}
string typeNs = NameFunc.GetNamespaceOfClassName(itemsRef.Id);
string typeName = NameFunc.RefineTypeName(itemsRef.Id, typeNs);
var existing = FindTypeDeclarationInNamespaces(typeName, typeNs);
if (existing == null) //so process itemsRef.Id first before considering type alias
{
AddTypeToCodeDom(new KeyValuePair <string, OpenApiSchema>(itemsRef.Id, FindSchema(itemsRef.Id)));
RemoveRegisteredSchemaRefId(itemsRef.Id);
}
//Array type with ref to the other type
if (TypeAliasDic.TryGet(itemsRef.Id, out string arrayTypeAlias))
{
TypeAliasDic.Add(item.Key, $"{arrayTypeAlias}[]");
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {arrayTypeAlias}[]) with existing ({itemsRef.Id}, {arrayTypeAlias})");
}
else
{
TypeAliasDic.Add(item.Key, $"{itemsRef.Id}[]");
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {itemsRef.Id}[])");
}
}
else if (type != "object" && !String.IsNullOrEmpty(type))
{
var clrType = TypeRefHelper.PrimitiveSwaggerTypeToClrType(type, null);
TypeAliasDic.Add(item.Key, clrType.FullName);
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {clrType.FullName}) -- clrType: {clrType.FullName}");
}
else if (type == "object" || String.IsNullOrEmpty(type)) //object alias without properties
{
typeDeclaration = AddTypeToClassNamespace(currentTypeName, ns);
CreateTypeDocComment(item, typeDeclaration);
}
else
{
Trace.TraceInformation($"Type Alias {item.Key} for type {type} is skipped.");
RemoveRegisteredSchemaRefId(item.Key);
return;
}
if (typeDeclaration != null)
{
Trace.TraceInformation($"TS clientClass {currentTypeName} created for {item.Key}");
}
else
{
Trace.TraceInformation($"TS Candidate clientClass {currentTypeName} for {item.Key} is skipped");
}
}
else
{
typeDeclaration = PodGenHelper.CreatePodClientEnum(ClientNamespace, currentTypeName);
CreateTypeDocComment(item, typeDeclaration);
AddEnumMembers(typeDeclaration, enumTypeList);
Trace.TraceInformation("TS client enum: " + currentTypeName);
}
RemoveRegisteredSchemaRefId(item.Key);
}
protected override void AddProperty(KeyValuePair <string, OpenApiSchema> p, CodeTypeDeclaration typeDeclaration, OpenApiSchema schema, string currentTypeName, string ns)
{
string propertyName = NameFunc.RefineTsPropertyName(p.Key);
if (propertyName == currentTypeName)
{
Trace.TraceWarning($"Property {propertyName} found with the same name of type {currentTypeName}, and it is renamed to {propertyName}1.");
propertyName += "1";
}
if (!Char.IsLetter(propertyName[0]) && propertyName[0] != '_')
{
propertyName = "_" + propertyName;
}
OpenApiSchema propertySchema = p.Value;
string primitivePropertyType = propertySchema.Type;
bool isPrimitiveType = TypeRefHelper.IsPrimitiveTypeOfOA(primitivePropertyType);
bool isRequired = schema.Required.Contains(p.Key); //compare with the original key
CodeMemberField clientProperty;
if (String.IsNullOrEmpty(primitivePropertyType))
{
if (propertySchema.Reference != null)
{
string propertyTypeNs = NameFunc.GetNamespaceOfClassName(propertySchema.Reference.Id);
string propertyTypeName = NameFunc.RefineTypeName(propertySchema.Reference.Id, propertyTypeNs);
string propertyTypeWithNs = NameFunc.CombineNamespaceWithClassName(propertyTypeNs, propertyTypeName);
CodeTypeReference ctr = ComponentsHelper.TranslateTypeNameToClientTypeReference(propertyTypeWithNs);
clientProperty = CreateProperty(ctr, propertyName, isRequired); //TS
}
else
{
if (propertySchema.Enum.Count > 0) //for casual enum
{
clientProperty = GenerateCasualEnumForProperty(propertySchema, typeDeclaration.Name, propertyName, ns, isRequired);
}
else
{
var r = CreateCodeTypeReferenceSchemaOf(propertySchema, currentTypeName, p.Key);
clientProperty = CreateProperty(r.Item1, propertyName, isRequired);
}
}
}
else
{
if (propertySchema.Type == "array") // for array
{
var r = CreateArrayCodeTypeReference(propertySchema, typeDeclaration.Name, propertyName, currentTypeName, ns);
CodeTypeReference arrayCodeTypeReference = r.Item1;
var n = String.IsNullOrEmpty(r.Item2) ? propertyName : r.Item2;
clientProperty = CreateProperty(arrayCodeTypeReference, n, isRequired);
}
else if (propertySchema.Enum.Count == 0 && propertySchema.Reference != null && !isPrimitiveType) // for complex type
{
CodeTypeReference complexCodeTypeReference = CreateComplexCodeTypeReference(propertySchema);
clientProperty = CreateProperty(complexCodeTypeReference, propertyName, isRequired);
}
else if (propertySchema.Reference == null && propertySchema.Properties != null && propertySchema.Properties.Count > 0) // for casual type
{
string casualTypeName = currentTypeName + NameFunc.RefinePropertyName(propertyName);
CodeTypeDeclaration casualTypeDeclaration = AddTypeToClassNamespace(casualTypeName, null); //stay with the namespace of the host class
AddProperties(casualTypeDeclaration, propertySchema, casualTypeName, null);
var ctr = TypeRefHelper.TranslateToClientTypeReference(casualTypeName);
clientProperty = CreateProperty(ctr, propertyName, isRequired);
}
else if (propertySchema.Type == "object" && propertySchema.AdditionalProperties != null) // for dictionary
{
CodeTypeReference dicKeyTypeRef = TypeRefHelper.TranslateToClientTypeReference(typeof(string));
CodeTypeReference dicValueTypeRef;
if (propertySchema.AdditionalProperties.Properties.Count == 0 && //not casual type
propertySchema.AdditionalProperties.Reference == null && // not complex type
propertySchema.AdditionalProperties.Items == null) // not casual array type
{
dicValueTypeRef = new CodeTypeReference(typeof(object));
}
else
{
dicValueTypeRef = PropertySchemaToCodeTypeReference(propertySchema.AdditionalProperties, typeDeclaration.Name, propertyName);
}
CodeTypeReference dicCtr = new CodeTypeReference(typeof(Dictionary <,>).FullName, dicKeyTypeRef, dicValueTypeRef); //for client codes, Dictionary is better than IDictionary, no worry of different implementation of IDictionary
clientProperty = CreateProperty(dicCtr, propertyName, isRequired);
}
else if (propertySchema.Enum.Count == 0) // for primitive type
{
Type simpleType = TypeRefHelper.PrimitiveSwaggerTypeToClrType(primitivePropertyType, propertySchema.Format);
clientProperty = CreatePropertyOfType(propertyName, simpleType, isRequired);
}
else if (propertySchema.Enum.Count > 0 && propertySchema.Type == "string") // for enum
{
string[] enumMemberNames;
try
{
enumMemberNames = (String.IsNullOrEmpty(propertySchema.Type) || propertySchema.Type == "string")
? propertySchema.Enum.Cast <OpenApiString>().Select(m => m.Value).ToArray()
: propertySchema.Enum.Cast <OpenApiInteger>().Select(m => "_" + m.Value.ToString()).ToArray();
}
catch (InvalidCastException ex)
{
throw new CodeGenException($"When dealing with {propertyName} of {propertySchema.Type}, error: {ex.Message}");
}
CodeTypeDeclaration existingDeclaration = FindEnumDeclaration(enumMemberNames);
if (existingDeclaration != null)
{
string existingTypeName = existingDeclaration.Name;
CodeTypeReference enumReference = TypeRefHelper.TranslateToClientTypeReference(existingTypeName);
clientProperty = CreateProperty(enumReference, propertyName, isRequired);
}
else
{
clientProperty = GenerateCasualEnumForProperty(propertySchema, typeDeclaration.Name, propertyName, ns, isRequired);
}
}
else if (propertySchema.Type != "string" && TypeAliasDic.TryGet(propertySchema.Type, out string aliasTypeName)) //check TypeAliasDic
{
var r = new CodeTypeReference(aliasTypeName);
clientProperty = CreateProperty(r, propertyName, isRequired);
}
else if (propertySchema.Reference != null)
{
CodeTypeReference complexCodeTypeReference = CreateComplexCodeTypeReference(propertySchema);
clientProperty = CreateProperty(complexCodeTypeReference, propertyName, isRequired);
}
else // for casual enum
{
clientProperty = GenerateCasualEnumForProperty(propertySchema, typeDeclaration.Name, propertyName, ns, isRequired);
}
}
CreateMemberDocComment(p, clientProperty);
typeDeclaration.Members.Add(clientProperty);
}
/// <summary>
/// The Id will be translated to proper C# type name and namespace if the YAML does support namespace in components.
/// </summary>
/// <param name="item">Reference Id and its schema</param>
public override void AddTypeToCodeDom(KeyValuePair <string, OpenApiSchema> item)
{
string ns = NameFunc.GetNamespaceOfClassName(item.Key);
string currentTypeName = NameFunc.RefineTypeName(item.Key, ns);
RegisterSchemaRefIdToBeAdded(item.Key);
OpenApiSchema schema = item.Value;
string type = schema.Type;
IList <OpenApiSchema> allOfBaseTypeSchemaList = schema.AllOf; //maybe empty
IList <IOpenApiAny> enumTypeList = schema.Enum; //maybe empty
bool isForClass = enumTypeList.Count == 0;
CodeTypeDeclaration typeDeclaration = null;
if (isForClass)
{
if (schema.Properties.Count > 0 || (schema.Properties.Count == 0 && allOfBaseTypeSchemaList.Count > 1))
{
typeDeclaration = AddTypeToClassNamespace(currentTypeName, ns);
if (String.IsNullOrEmpty(type) && allOfBaseTypeSchemaList.Count > 0)
{
OpenApiSchema allOfRef = allOfBaseTypeSchemaList[0];
if (allOfRef.Reference == null)
{
Trace.TraceWarning($"Not yet support Type {item.Key} having allOf[0] without Reference. Skipped.");
RemoveRegisteredSchemaRefId(item.Key);
return;
}
string baseTypeName = NameFunc.RefineTypeName(allOfRef.Reference.Id, ns); //pointing to parent class
typeDeclaration.BaseTypes.Add(baseTypeName);
if (allOfBaseTypeSchemaList.Count > 1)
{
OpenApiSchema allOfProperteisSchema = allOfBaseTypeSchemaList[1]; //the 2nd one points to properties of the derived type, while the 1st one points to the base type.
AddProperties(typeDeclaration, allOfProperteisSchema, currentTypeName, ns);
}
}
CreateTypeDocComment(item, typeDeclaration);
AddProperties(typeDeclaration, schema, currentTypeName, ns);
if (settings.DecorateDataModelWithDataContract)
{
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.Serialization.DataContract", new CodeAttributeArgument("Namespace", new CodeSnippetExpression($"\"{settings.DataContractNamespace}\""))));
}
if (settings.DecorateDataModelWithSerializable)
{
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.SerializableAttribute"));
}
}
else if (type == "array") // wrapper of array. Microsoft OpenApi library could not intepret this as type alias, so I have to register the alias myself.
{
OpenApiReference itemsRef = schema.Items.Reference;
if (itemsRef == null) //Array type with casual schema
{
if (schema.Items.Properties.Count > 0) //casual member type definition in an array type
{
string newTypeName = currentTypeName + "Element";
if (FindTypeDeclarationInNamespaces(newTypeName, ns) == null)
{
AddTypeToCodeDom(new KeyValuePair <string, OpenApiSchema>(newTypeName, schema.Items)); //so add casual type recursively
var typeNameX = TypeRefHelper.ArrayAsIEnumerableDerivedToType(newTypeName, settings.ArrayAs);
TypeAliasDic.Add(item.Key, typeNameX);
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {typeNameX}) -- generated: {newTypeName}");
}
}
else
{
RemoveRegisteredSchemaRefId(item.Key);
Trace.TraceWarning($"Not yet support array type with casual items type without reference and without casual properties: {item.Key}. Skipped.");
}
return;
}
string typeNs = NameFunc.GetNamespaceOfClassName(itemsRef.Id);
string typeName = NameFunc.RefineTypeName(itemsRef.Id, typeNs);
CodeTypeDeclaration existing = FindTypeDeclarationInNamespaces(typeName, typeNs);
if (existing == null) //so process itemsRef.Id first before considering type alias
{
AddTypeToCodeDom(new KeyValuePair <string, OpenApiSchema>(itemsRef.Id, FindSchema(itemsRef.Id)));
RemoveRegisteredSchemaRefId(itemsRef.Id);
}
//Array type with ref to the other type
if (TypeAliasDic.TryGet(itemsRef.Id, out string arrayTypeAlias))
{
var typeNameX = TypeRefHelper.ArrayAsIEnumerableDerivedToType(arrayTypeAlias, settings.ArrayAs);
TypeAliasDic.Add(item.Key, typeNameX);
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {typeNameX}) with existing ({itemsRef.Id}, {arrayTypeAlias})");
}
else
{
var typeNameX = TypeRefHelper.ArrayAsIEnumerableDerivedToType(itemsRef.Id, settings.ArrayAs);
TypeAliasDic.Add(item.Key, typeNameX);
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {typeNameX})");
}
}
else if (type != "object" && !String.IsNullOrEmpty(type))
{
Type clrType = TypeRefHelper.PrimitiveSwaggerTypeToClrType(type, null);
TypeAliasDic.Add(item.Key, clrType.FullName);
Trace.TraceInformation($"TypeAliasDic.Add({item.Key}, {clrType.FullName}) -- clrType: {clrType.FullName}");
}
else if (type == "object" || String.IsNullOrEmpty(type)) //object alias without properties
{
typeDeclaration = AddTypeToClassNamespace(currentTypeName, ns);
CreateTypeDocComment(item, typeDeclaration);
if (settings.DecorateDataModelWithDataContract)
{
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.Serialization.DataContract", new CodeAttributeArgument("Namespace", new CodeSnippetExpression($"\"{settings.DataContractNamespace}\""))));
}
if (settings.DecorateDataModelWithSerializable)
{
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.SerializableAttribute"));
}
}
else
{
Trace.TraceInformation($"Type Alias {item.Key} for type {type} is skipped.");
RemoveRegisteredSchemaRefId(item.Key);
return;
}
if (typeDeclaration != null)
{
Trace.TraceInformation($"clientClass {currentTypeName} created for {item.Key}");
}
else
{
Trace.TraceInformation($"Candidate clientClass {currentTypeName} for {item.Key} is skipped");
}
}
else
{
typeDeclaration = PodGenHelper.CreatePodClientEnum(ClientNamespace, currentTypeName);
CreateTypeDocComment(item, typeDeclaration);
AddEnumMembers(typeDeclaration, enumTypeList);
if (settings.DecorateDataModelWithDataContract)
{
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.Serialization.DataContract", new CodeAttributeArgument("Namespace", new CodeSnippetExpression($"\"{settings.DataContractNamespace}\""))));
//net 5.0 https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-customize-properties#enums-as-strings
if (settings.EnumToString)
{
if (settings.UseSystemTextJson)
{
//[System.Text.Json.Serialization.JsonConverter(typeof(System.Text.Json.Serialization.JsonStringEnumConverter))]
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.Text.Json.Serialization.JsonConverter", new CodeAttributeArgument(new CodeSnippetExpression("typeof(System.Text.Json.Serialization.JsonStringEnumConverter)"))));
}
else
{
//[JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("Newtonsoft.Json.JsonConverter", new CodeAttributeArgument(new CodeSnippetExpression("typeof(Newtonsoft.Json.Converters.StringEnumConverter)"))));
}
}
}
if (settings.DecorateDataModelWithSerializable)
{
typeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration("System.SerializableAttribute"));
}
Trace.TraceInformation("client enum: " + currentTypeName);
}
RemoveRegisteredSchemaRefId(item.Key);
}
protected override void AddProperty(KeyValuePair <string, OpenApiSchema> p, CodeTypeDeclaration typeDeclaration, OpenApiSchema schema, string currentTypeName, string ns)
{
string propertyName = NameFunc.RefinePropertyName(p.Key);
if (propertyName == currentTypeName)
{
Trace.TraceWarning($"Property {propertyName} found with the same name of type {currentTypeName}, and it is renamed to {propertyName}1.");
propertyName += "1";
}
if (!Char.IsLetter(propertyName[0]) && propertyName[0] != '_')
{
propertyName = "_" + propertyName;
}
bool propertyNameAdjusted = propertyName != p.Key;
OpenApiSchema propertySchema = p.Value;
string primitivePropertyType = propertySchema.Type;
bool isPrimitiveType = TypeRefHelper.IsPrimitiveTypeOfOA(primitivePropertyType);
bool isRequired = schema.Required.Contains(p.Key); //compare with the original key
string defaultValue = GetDefaultValue(propertySchema);
CodeMemberField clientProperty;
if (String.IsNullOrEmpty(primitivePropertyType))
{
if (propertySchema.Reference != null)
{
string propertyTypeNs = NameFunc.GetNamespaceOfClassName(propertySchema.Reference.Id);
string propertyTypeName = NameFunc.RefineTypeName(propertySchema.Reference.Id, propertyTypeNs);
string propertyTypeWithNs = NameFunc.CombineNamespaceWithClassName(propertyTypeNs, propertyTypeName);
CodeTypeReference ctr = ComponentsHelper.TranslateTypeNameToClientTypeReference(propertyTypeWithNs);
clientProperty = CreateProperty(ctr, propertyName, defaultValue); //C#
}
else
{
if (propertySchema.Enum.Count > 0) //for casual enum
{
clientProperty = GenerateCasualEnumForProperty(propertySchema, typeDeclaration.Name, propertyName, ns, defaultValue, !isRequired || propertySchema.Nullable);
}
else
{
Tuple <CodeTypeReference, bool> r = CreateCodeTypeReferenceSchemaOf(propertySchema, currentTypeName, p.Key);
bool isClass = r.Item2;
if ((!settings.DisableSystemNullableByDefault && !isRequired || propertySchema.Nullable) && !isClass) //C#.
//if (!settings.DisableSystemNullableByDefault && !isClass && !isRequired || propertySchema.Nullable) //C#
{
clientProperty = CreateNullableProperty(r.Item1, propertyName);
}
else if (isClass && propertySchema.Nullable && settings.UseNullableReferenceType) //vimeo yaml declares a reference type as nullable.
{
clientProperty = CreateNullableProperty(r.Item1, propertyName);
}
else
{
clientProperty = CreateProperty(r.Item1, propertyName, defaultValue);
}
}
}
}
else
{
if (propertySchema.Type == "array") // for array
{
Tuple <CodeTypeReference, string> r = CreateArrayCodeTypeReference(propertySchema, typeDeclaration.Name, propertyName, currentTypeName, ns);
CodeTypeReference arrayCodeTypeReference = r.Item1;
string n = String.IsNullOrEmpty(r.Item2) ? propertyName : r.Item2;
clientProperty = CreateProperty(arrayCodeTypeReference, n, defaultValue);
}
else if (propertySchema.Enum.Count == 0 && propertySchema.Reference != null && !isPrimitiveType) // for complex type
{
CodeTypeReference complexCodeTypeReference = CreateComplexCodeTypeReference(propertySchema);
clientProperty = CreateProperty(complexCodeTypeReference, propertyName, defaultValue);
}
else if (propertySchema.Reference == null && propertySchema.Properties != null && propertySchema.Properties.Count > 0) // for casual type
{
string casualTypeName = currentTypeName + NameFunc.RefinePropertyName(propertyName);
CodeTypeDeclaration found = FindTypeDeclarationInNamespaces(casualTypeName, null); //It could happenen when generating sync and async functions in C#
if (found == null)
{
CodeTypeDeclaration casualTypeDeclaration = AddTypeToClassNamespace(casualTypeName, null); //stay with the namespace of the host class
AddProperties(casualTypeDeclaration, propertySchema, casualTypeName, null);
}
CodeTypeReference ctr = TypeRefHelper.TranslateToClientTypeReference(casualTypeName);
clientProperty = CreateProperty(ctr, propertyName, defaultValue);
}
else if (propertySchema.Type == "object" && propertySchema.AdditionalProperties != null) // for dictionary
{
CodeTypeReference dicKeyTypeRef = TypeRefHelper.TranslateToClientTypeReference(typeof(string));
CodeTypeReference dicValueTypeRef;
if (propertySchema.AdditionalProperties.Properties.Count == 0 && //not casual type
propertySchema.AdditionalProperties.Reference == null && // not complex type
propertySchema.AdditionalProperties.Items == null) // not casual array type
{
dicValueTypeRef = new CodeTypeReference(typeof(object));
}
else
{
dicValueTypeRef = PropertySchemaToCodeTypeReference(propertySchema.AdditionalProperties, typeDeclaration.Name, propertyName);
}
CodeTypeReference dicCtr = new CodeTypeReference(typeof(Dictionary <,>).FullName, dicKeyTypeRef, dicValueTypeRef); //for client codes, Dictionary is better than IDictionary, no worry of different implementation of IDictionary
clientProperty = CreateProperty(dicCtr, propertyName, null);
}
else if (propertySchema.Enum.Count == 0) // for primitive type
{
Type simpleType = TypeRefHelper.PrimitiveSwaggerTypeToClrType(primitivePropertyType, propertySchema.Format);
if ((!settings.DisableSystemNullableByDefault && !isRequired || propertySchema.Nullable) && !simpleType.IsClass) //C#
{
clientProperty = CreateNullableProperty(propertyName, simpleType, settings, propertySchema.Nullable);
}
else if (propertySchema.Nullable && simpleType.IsClass && settings.UseNullableReferenceType)
{
clientProperty = CreateNullableProperty(propertyName, simpleType, settings, propertySchema.Nullable);
}
else
{
clientProperty = CreateProperty(propertyName, simpleType, defaultValue);
}
}
else if (propertySchema.Enum.Count > 0 && propertySchema.Type == "string") // for enum
{
string[] enumMemberNames;
try
{
enumMemberNames = (String.IsNullOrEmpty(propertySchema.Type) || propertySchema.Type == "string")
? propertySchema.Enum.Cast <OpenApiString>().Select(m => m.Value).ToArray()
: propertySchema.Enum.Cast <OpenApiInteger>().Select(m => "_" + m.Value.ToString()).ToArray();
}
catch (InvalidCastException ex)
{
throw new CodeGenException($"When dealing with {propertyName} of {propertySchema.Type}, error: {ex.Message}");
}
CodeTypeDeclaration existingDeclaration = FindEnumDeclaration(enumMemberNames);
if (existingDeclaration != null)
{
string existingTypeName = existingDeclaration.Name;
CodeTypeReference enumReference = TypeRefHelper.TranslateToClientTypeReference(existingTypeName);
clientProperty = CreateProperty(enumReference, propertyName, String.IsNullOrEmpty(defaultValue) ? null : enumReference.BaseType + "." + defaultValue);
}
else
{
clientProperty = GenerateCasualEnumForProperty(propertySchema, typeDeclaration.Name, propertyName, ns, defaultValue, !isRequired || propertySchema.Nullable);
}
}
else if (propertySchema.Type != "string" && TypeAliasDic.TryGet(propertySchema.Type, out string aliasTypeName)) //check TypeAliasDic
{
CodeTypeReference r = new CodeTypeReference(aliasTypeName);
clientProperty = CreateProperty(r, propertyName, defaultValue);
}
else if (propertySchema.Reference != null)
{
CodeTypeReference complexCodeTypeReference = CreateComplexCodeTypeReference(propertySchema);
clientProperty = CreateProperty(complexCodeTypeReference, propertyName, String.IsNullOrEmpty(defaultValue) ? null : complexCodeTypeReference.BaseType + "." + defaultValue);
}
else // for casual enum
{
clientProperty = GenerateCasualEnumForProperty(propertySchema, typeDeclaration.Name, propertyName, ns, defaultValue, !isRequired || propertySchema.Nullable);
}
}
if (isRequired)
{
clientProperty.CustomAttributes.Add(new CodeAttributeDeclaration("System.ComponentModel.DataAnnotations.Required"));
}
if (settings.DecorateDataModelWithDataContract)
{
if (propertyNameAdjusted)
{
string originalPropertyName = p.Key;
clientProperty.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.Serialization.DataMember", new CodeAttributeArgument("Name", new CodeSnippetExpression($"\"{originalPropertyName}\""))));
}
else
{
clientProperty.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.Serialization.DataMember"));
}
}
if (settings.DataAnnotationsEnabled) //C#
{
AddValidationAttributes(propertySchema, clientProperty);
}
if (settings.DecorateDataModelWithPropertyName) //C#
{
string originalPropertyName = p.Key;
if (settings.UseSystemTextJson)
{
//[System.Text.Json.Serialization.JsonPropertyName("name")]
clientProperty.CustomAttributes.Add(new CodeAttributeDeclaration("System.Text.Json.Serialization.JsonPropertyName", new CodeAttributeArgument(new CodeSnippetExpression($"\"{originalPropertyName}\""))));
}
else
{
//[Newtonsoft.Json.JsonProperty(PropertyName = "name")]
clientProperty.CustomAttributes.Add(new CodeAttributeDeclaration("Newtonsoft.Json.JsonProperty", new CodeAttributeArgument("PropertyName", new CodeSnippetExpression($"\"{originalPropertyName}\""))));
}
}
CreateMemberDocComment(p, clientProperty);
typeDeclaration.Members.Add(clientProperty);
}