/// <summary>
/// 更新信息
/// </summary>
public int UpdateInfo(SqlTransaction trans, ClassTemplateModel claModel, int ClassTemplateId)
{
string key = "Cache_ClassTemplate_Model_" + ClassTemplateId;
CacheHelper.RemoveCache(key);
return(claDAL.UpdateInfo(trans, claModel, ClassTemplateId));
}
public ITemplate CreateTemplate(string language, string templateName, object model)
{
ITemplate template = _defaultFactory.CreateTemplate(language, templateName, model);
if (templateName.StartsWith("Client.Class.Body"))
{
// This gets called before the Class.Body template so use it to get the client template model
_clientTemplateModel = (CSharpClientTemplateModel)HashObjectProperty.GetValue(model);
}
if (templateName.StartsWith("Class.Body"))
{
// Get all the operations so we can create proxies in the model objects
ClassTemplateModel classTemplateModel = (ClassTemplateModel)HashObjectProperty.GetValue(model);
return(new ClassBodyTemplate(classTemplateModel, _clientTemplateModel));
}
if (templateName == "Class.Inheritance")
{
// Add IClientModel to the interface list
return(new ClassInheritanceTemplate(template));
}
if (templateName == "Class.Constructor")
{
// Changes the constructor to take a NetlifyClient
ClassTemplateModel classTemplateModel = (ClassTemplateModel)HashObjectProperty.GetValue(model);
return(new ClassConstructorTemplate(classTemplateModel, _clientSettings));
}
return(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 CodeArtifact GenerateClass(JsonSchema4 schema, string typeName)
{
var model = new ClassTemplateModel(typeName, Settings, _resolver, schema, RootObject);
RenamePropertyWithSameNameAsClass(typeName, model.Properties);
var template = Settings.TemplateFactory.CreateTemplate("CSharp", "Class", model);
return(new CodeArtifact(typeName, model.BaseClassName, CodeArtifactType.Class, CodeArtifactLanguage.CSharp, template));
}
private TypeGeneratorResult GenerateClass(string typeName)
{
var model = new ClassTemplateModel(typeName, Settings, _resolver, _schema, RootObject);
RenamePropertyWithSameNameAsClass(typeName, model.Properties);
var template = Settings.TemplateFactory.CreateTemplate("CSharp", "Class", model);
return(new TypeGeneratorResult
{
TypeName = typeName,
BaseTypeName = model.BaseClass,
Code = template.Render()
});
}
/// <summary>
/// 从缓存读取信息
/// </summary>
public ClassTemplateModel GetCacheInfo(SqlTransaction trans, int ClassTemplateId)
{
string key = "Cache_ClassTemplate_Model_" + ClassTemplateId;
object value = CacheHelper.GetCache(key);
if (value != null)
{
return((ClassTemplateModel)value);
}
else
{
ClassTemplateModel claModel = claDAL.GetInfo(trans, ClassTemplateId);
CacheHelper.AddCache(key, claModel, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(20), CacheItemPriority.Normal, null);
return(claModel);
}
}
private TypeGeneratorResult GenerateClass(string typeName)
{
var properties = _schema.Properties.Values
.Select(property => new PropertyModel(property, _resolver, Settings))
.ToList();
var model = new ClassTemplateModel(typeName, Settings, _resolver, _schema, properties);
var template = new ClassTemplate() as ITemplate;
template.Initialize(model);
return(new TypeGeneratorResult
{
TypeName = typeName,
BaseTypeName = model.BaseClass,
Code = template.Render()
});
}
private TypeGeneratorResult GenerateClass(string typeName)
{
var properties = _schema.ActualProperties.Values
.Where(p => !p.IsInheritanceDiscriminator)
.Select(property => new PropertyModel(property, _resolver, Settings))
.ToList();
RenamePropertyWithSameNameAsClass(typeName, properties);
var model = new ClassTemplateModel(typeName, Settings, _resolver, _schema, properties);
var template = Settings.TemplateFactory.CreateTemplate("CSharp", "Class", model);
return(new TypeGeneratorResult
{
TypeName = typeName,
BaseTypeName = model.BaseClass,
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));
}
}
public ClassTemplate(ClassTemplateModel model)
{
Model = model;
}
public ClassConstructorTemplate(ClassTemplateModel classTemplateModel, CSharpClientGeneratorSettings clientSettings)
{
_classTemplateModel = classTemplateModel ?? throw new ArgumentNullException(nameof(classTemplateModel));
_clientSettings = clientSettings ?? throw new ArgumentNullException(nameof(clientSettings));
}
/// <summary>
/// 插入信息
/// </summary>
public int InsertInfo(SqlTransaction trans, ClassTemplateModel claModel)
{
return(claDAL.InsertInfo(trans, claModel));
}
/// <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 ClassBodyTemplate(ClassTemplateModel classTemplateModel, CSharpClientTemplateModel clientTemplateModel)
{
_classTemplateModel = classTemplateModel ?? throw new ArgumentNullException(nameof(classTemplateModel));
_clientTemplateModel = clientTemplateModel ?? throw new ArgumentNullException(nameof(clientTemplateModel));
}
/// <summary>Initializes the template with a model.</summary>
/// <param name="model">The model.</param>
public void Initialize(object model)
{
Model = (ClassTemplateModel)model;
}
public CSharpClassTemplate(ClassTemplateModel model, CSharpClassTemplateOptions options)
{
Model = model;
Options = options;
}