private CodeArtifact GenerateEnum(JsonSchema4 schema, string typeName)
{
var model = new EnumTemplateModel(typeName, schema, Settings);
var template = Settings.TemplateFactory.CreateTemplate("CSharp", "Enum", model);
return(new CodeArtifact(typeName, CodeArtifactType.Enum, CodeArtifactLanguage.CSharp, template));
}
/// <summary>Generates the type.</summary>
/// <param name="typeNameHint">The fallback type name.</param>
/// <returns>The code.</returns>
public override TypeGeneratorResult GenerateType(string typeNameHint)
{
var typeName = _resolver.GetOrGenerateTypeName(_schema, typeNameHint);
if (_schema.IsEnumeration)
{
var model = new EnumTemplateModel(typeName, _schema, Settings);
var template = Settings.TemplateFactory.CreateTemplate("TypeScript", "Enum", model);
return(new TypeGeneratorResult
{
TypeName = typeName,
Code = template.Render()
});
}
else
{
var model = new ClassTemplateModel(typeName, typeNameHint, Settings, _resolver, _schema, RootObject);
var template = Settings.CreateTemplate(typeName, model);
return(new TypeGeneratorResult
{
TypeName = typeName,
BaseTypeName = model.BaseClass,
Code = template.Render()
});
}
}
private TypeGeneratorResult GenerateEnum(string typeName)
{
var model = new EnumTemplateModel(typeName, _schema, Settings);
var template = Settings.TemplateFactory.CreateTemplate("CSharp", "Enum", model);
return(new TypeGeneratorResult
{
TypeName = typeName,
Code = template.Render()
});
}
/// <summary>Generates the type.</summary>
/// <param name="schema">The schema.</param>
/// <param name="typeNameHint">The fallback type name.</param>
/// <returns>The code.</returns>
protected override CodeArtifact GenerateType(JsonSchema schema, string typeNameHint)
{
var typeName = _resolver.GetOrGenerateTypeName(schema, typeNameHint);
if (schema.IsEnumeration)
{
var model = new EnumTemplateModel(typeName, schema, Settings);
var template = Settings.TemplateFactory.CreateTemplate("TypeScript", "Enum", model);
return(new CodeArtifact(typeName, CodeArtifactType.Enum, CodeArtifactLanguage.TypeScript, CodeArtifactCategory.Contract, template));
}
else
{
var model = new ClassTemplateModel(typeName, typeNameHint, Settings, _resolver, schema, RootObject);
var template = Settings.CreateTemplate(typeName, model);
var type = Settings.TypeStyle == TypeScriptTypeStyle.Interface
? CodeArtifactType.Interface
: CodeArtifactType.Class;
return(new CodeArtifact(typeName, model.BaseClass, type, CodeArtifactLanguage.TypeScript, CodeArtifactCategory.Contract, template));
}
}
/// <summary>Generates the type.</summary>
/// <param name="schema">The schema.</param>
/// <param name="typeNameHint">The fallback type name.</param>
/// <returns>The code.</returns>
protected override CodeArtifact GenerateType(JsonSchema schema, string typeNameHint)
{
var typeName = _resolver.GetOrGenerateTypeName(schema, typeNameHint);
if (schema.IsEnumeration)
{
var model = new EnumTemplateModel(typeName, schema, Settings);
string templateName;
if (Settings.EnumStyle == TypeScriptEnumStyle.Enum)
{
templateName = nameof(TypeScriptEnumStyle.Enum);
}
else if (Settings.EnumStyle == TypeScriptEnumStyle.StringLiteral)
{
templateName = $"{nameof(TypeScriptEnumStyle.Enum)}.{nameof(TypeScriptEnumStyle.StringLiteral)}";
}
else
{
throw new ArgumentOutOfRangeException(nameof(Settings.EnumStyle), Settings.EnumStyle, "Unknown enum style");
}
var template = Settings.TemplateFactory.CreateTemplate("TypeScript", templateName, model);
return(new CodeArtifact(typeName, CodeArtifactType.Enum, CodeArtifactLanguage.TypeScript, CodeArtifactCategory.Contract, template));
}
else
{
var model = new ClassTemplateModel(typeName, typeNameHint, Settings, _resolver, schema, RootObject);
var template = Settings.CreateTemplate(typeName, model);
var type = Settings.TypeStyle == TypeScriptTypeStyle.Interface
? CodeArtifactType.Interface
: CodeArtifactType.Class;
return(new CodeArtifact(typeName, model.BaseClass, type, CodeArtifactLanguage.TypeScript, CodeArtifactCategory.Contract, template));
}
}
/// <summary>Initializes the template with a model.</summary>
/// <param name="model">The model.</param>
public void Initialize(object model)
{
Model = (EnumTemplateModel)model;
}
/// <summary>
/// Generate Dto Class
/// </summary>
/// <param name="schema"></param>
/// <param name="typeNameHint"></param>
/// <param name="className"></param>
/// <returns></returns>
public string GenerateDtoClass(JsonSchema schema, string typeNameHint, out string className)
{
string appendCode = string.Empty;
var typeName = _resolver.GetOrGenerateTypeName(schema, typeNameHint);
if (schema.IsEnumeration)
{
var model = new EnumTemplateModel(string.IsNullOrWhiteSpace(typeName) ? typeNameHint : typeName, schema,
_resolver.Settings);
var template = _resolver.Settings.TemplateFactory.CreateTemplate("TypeScript", "Enum", model);
var codeArtifact = new CodeArtifact(string.IsNullOrWhiteSpace(typeName) ? typeNameHint : typeName,
CodeArtifactType.Enum, CodeArtifactLanguage.TypeScript, CodeArtifactCategory.Undefined, template);
className = codeArtifact.TypeName;
return(codeArtifact.Code);
}
else
{
var model = new ClassTemplateModel(typeName, typeNameHint, _resolver.Settings, _resolver, schema,
schema);
Dictionary <string, List <string> > typeNames = new Dictionary <string, List <string> >();
List <string> enumNames = new List <string>();
List <string> nswagTypes = new List <string>();
StringBuilder builder = new StringBuilder();
foreach (var parent in schema.AllOf)
{
var type = _resolver.GetOrGenerateTypeName(parent, string.Empty);
var list = new List <string>();
if (_resolver.Settings.GenerateConstructorInterface)
{
list.Add(_resolver.ResolveConstructorInterfaceName(parent, true, string.Empty));
}
list.Add(type);
typeNames.AddIfNot(type, list);
}
foreach (var actualProperty in schema.ActualProperties)
{
if (actualProperty.Value.IsEnumeration && actualProperty.Value.Reference == null)
{
appendCode = GenerateDtoClass(actualProperty.Value, actualProperty.Key, out _);
}
var property = new PropertyModel(model, actualProperty.Value, actualProperty.Key, _resolver,
_resolver.Settings);
var propertyType = property.Type.IndexOf("[", StringComparison.Ordinal) > 0
? property.Type.Replace("[]", "")
: property.Type;
if (!Constant.TsBaseType.Contains(propertyType) && !property.IsDictionary &&
!actualProperty.Value.IsEnumeration)
{
typeNames.AddIfNot(propertyType, new List <string> {
propertyType
});
}
if (Constant.UtilitiesModules.Contains(propertyType))
{
nswagTypes.Add(propertyType);
}
var propertyDictionaryItemType =
property.DictionaryItemType.IndexOf("[", StringComparison.Ordinal) > 0
? property.DictionaryItemType.Replace("[]", "")
: property.DictionaryItemType;
if (!Constant.TsBaseType.Contains(propertyDictionaryItemType))
{
typeNames.AddIfNot(propertyDictionaryItemType, new List <string>()
{
propertyDictionaryItemType
});
}
if (Constant.UtilitiesModules.Contains(propertyDictionaryItemType))
{
nswagTypes.Add(propertyDictionaryItemType);
}
var propertyArrayItemType = property.ArrayItemType.IndexOf("[", StringComparison.Ordinal) > 0
? property.ArrayItemType.Replace("[]", "")
: property.ArrayItemType;
if (!Constant.TsBaseType.Contains(propertyArrayItemType))
{
typeNames.AddIfNot(propertyArrayItemType, new List <string>()
{
propertyArrayItemType
});
}
if (Constant.UtilitiesModules.Contains(propertyArrayItemType))
{
nswagTypes.Add(propertyArrayItemType);
}
}
typeNames.Where(c => !nswagTypes.Contains(c.Key)).Where(c => c.Key != typeName).ToList()
.ForEach(c => builder.AppendLine($"import {{ {string.Join(",", c.Value)} }} from './{c.Key}';"));
enumNames.Distinct().Where(c => !nswagTypes.Contains(c)).Where(c => c != typeName).ToList()
.ForEach(c => builder.AppendLine($"import {{ {c} }} from './{c}';"));
if (nswagTypes.Any())
{
builder.AppendLine(
$"import {{ {string.Join(",", nswagTypes.Distinct())} }} from '{(string.IsNullOrWhiteSpace(_dtoDirName) ? "./" : "../")}Utilities';");
}
builder.AppendLine();
var template = _resolver.Settings.TemplateFactory.CreateTemplate("TypeScript", "Class", model);
className = model.ClassName;
return(string.Join("\n", builder.ToString(),
template.Render(), appendCode));
}
}
public EnumTemplate(EnumTemplateModel model)
{
Model = model;
}
