/// <summary>Generates the client class.</summary>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="controllerClassName">Name of the controller class.</param>
/// <param name="operations">The operations.</param>
/// <returns>The code.</returns>
protected override IEnumerable <CodeArtifact> GenerateClientTypes(string controllerName,
string controllerClassName, IEnumerable <CSharpOperationModel> operations)
{
var cSharpOperationModels = operations as CSharpOperationModel[] ?? operations.ToArray();
OpenApiTag tag = null;
var currentPath = cSharpOperationModels.FirstOrDefault()?.Path;
if (!string.IsNullOrWhiteSpace(currentPath))
{
var tagName = _document?.Operations?.FirstOrDefault(x => x.Path.EndsWith(currentPath))
?.Operation?.Tags
?.FirstOrDefault();
tag = _document?.Tags.FirstOrDefault(x => x.Name == tagName);
}
var model = new CSharpRefitTemplateModel(controllerClassName, cSharpOperationModels, _document, Settings, tag);
var template = Settings.CodeGeneratorSettings.TemplateFactory.CreateTemplate("CSharp", "Refit", model);
var data = new CodeArtifact(model.Class, CodeArtifactType.Class, CodeArtifactLanguage.CSharp,
CodeArtifactCategory.Client, template);
yield return(data);
}
/// <summary>
/// c#代码
/// </summary>
/// <param name="codeArtifact">源代码</param>
public CSharpCode(CodeArtifact codeArtifact)
: this(TransformCode(codeArtifact.Code), codeArtifact.TypeName, codeArtifact.Type)
{
}
/// <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));
}
}
/// <summary>
/// WebApiClient的模型描述
/// </summary>
/// <param name="codeArtifact">源代码</param>
/// <param name="nameSpace">命名空间</param>
public HttpModel(CodeArtifact codeArtifact, string nameSpace)
: base(codeArtifact)
{
this.AspNetNamespace = nameSpace;
}
/// <summary>
/// WebApiClient的模型描述
/// </summary>
/// <param name="codeArtifact">源代码</param>
/// <param name="nameSpace">命名空间</param>
public HttpModel(CodeArtifact codeArtifact, string nameSpace)
: base(codeArtifact)
{
this.NameSapce = nameSpace;
}
