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