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