private string GetInterfaceName(JsonSchema definition)
{
var interfaces = new List <string>();
if (definition.Properties.TryGetValue("metadata", out var metadataProperty))
{
interfaces.Add(
$"IKubernetesObject<{classNameHelper.GetClassNameForSchemaDefinition(metadataProperty.Reference)}>");
}
else
{
interfaces.Add("IKubernetesObject");
}
if (definition.Properties.TryGetValue("items", out var itemsProperty))
{
var schema = itemsProperty.Type == JsonObjectType.Object
? itemsProperty.Reference
: itemsProperty.Item.Reference;
interfaces.Add($"IItems<{classNameHelper.GetClassNameForSchemaDefinition(schema)}>");
}
if (definition.Properties.TryGetValue("spec", out var specProperty))
{
// ignore empty spec placeholder
if (specProperty.Reference?.ActualProperties.Any() == true)
{
interfaces.Add($"ISpec<{classNameHelper.GetClassNameForSchemaDefinition(specProperty.Reference)}>");
}
}
interfaces.Add("IValidate");
return(string.Join(", ", interfaces));
}
public string GetPlural(JsonSchema definition)
{
var className = classNameHelper.GetClassNameForSchemaDefinition(definition);
if (_classNameToPluralMap.TryGetValue(className, out var plural))
{
return(plural);
}
return(null);
}
public void GetDotNetType(RenderContext context, IList <object> arguments,
IDictionary <string, object> options,
RenderBlock fn, RenderBlock inverse)
{
if (arguments != null && arguments.Count > 0 && arguments[0] != null && arguments[0] is OpenApiParameter)
{
var parameter = arguments[0] as OpenApiParameter;
if (parameter.Schema?.Reference != null)
{
context.Write(classNameHelper.GetClassNameForSchemaDefinition(parameter.Schema.Reference));
}
else if (parameter.Schema != null)
{
context.Write(GetDotNetType(parameter.Schema.Type, parameter.Name, parameter.IsRequired,
parameter.Schema.Format));
}
else
{
context.Write(GetDotNetType(parameter.Type, parameter.Name, parameter.IsRequired,
parameter.Format));
}
}
else if (arguments != null && arguments.Count > 0 && arguments[0] != null && arguments[0] is JsonSchemaProperty)
{
var property = arguments[0] as JsonSchemaProperty;
context.Write(GetDotNetType(property));
}
else if (arguments != null && arguments.Count > 2 && arguments[0] != null && arguments[1] != null &&
arguments[2] != null && arguments[0] is JsonObjectType && arguments[1] is string &&
arguments[2] is bool)
{
context.Write(GetDotNetType((JsonObjectType)arguments[0], (string)arguments[1], (bool)arguments[2],
(string)arguments[3]));
}
else if (arguments != null && arguments.Count > 0 && arguments[0] != null)
{
context.Write($"ERROR: Expected OpenApiParameter but got {arguments[0].GetType().FullName}");
}
else
{
context.Write("ERROR: Expected a OpenApiParameter argument but got none.");
}
}
public void Generate(OpenApiDocument swagger, GeneratorExecutionContext context)
{
foreach (var kv in swagger.Definitions)
{
var def = kv.Value;
var clz = classNameHelper.GetClassNameForSchemaDefinition(def);
context.RenderToContext(
"Model.cs.template",
new { clz, def, properties = def.Properties.Values },
$"Models_{clz}.g.cs");
}
}
public void Generate(OpenApiDocument swagger, GeneratorExecutionContext context)
{
var allGeneratedModelClassNames = new List <string>();
foreach (var kv in swagger.Definitions)
{
var def = kv.Value;
var clz = classNameHelper.GetClassNameForSchemaDefinition(def);
allGeneratedModelClassNames.Add(clz);
}
var manualMaps = new List <(string, string)>();
var manualconverter = context.Compilation.SyntaxTrees.First(s => PathSuffixMath(s.FilePath, "Versioning/VersionConverter.cs"));
manualMaps = Regex.Matches(manualconverter.GetText().ToString(), @"\.CreateMap<(?<T1>.+?),\s?(?<T2>.+?)>")
.OfType <Match>()
.Select(x => (x.Groups["T1"].Value, x.Groups["T2"].Value))
.ToList();
var versionRegex = @"(^V|v)[0-9]+((alpha|beta)[0-9]+)?";
var typePairs = allGeneratedModelClassNames
.OrderBy(x => x)
.Select(x => new
{
Version = Regex.Match(x, versionRegex).Value?.ToLower(),
Kinda = Regex.Replace(x, versionRegex, string.Empty),
Type = x,
})
.Where(x => !string.IsNullOrEmpty(x.Version))
.GroupBy(x => x.Kinda)
.Where(x => x.Count() > 1)
.SelectMany(x =>
x.SelectMany((value, index) => x.Skip(index + 1), (first, second) => new { first, second }))
.OrderBy(x => x.first.Kinda)
.ThenBy(x => x.first.Version)
.Select(x => (x.first.Type, x.second.Type))
.ToList();
var versionConverterPairs = typePairs.Except(manualMaps).ToList();
var sbmodel = new StringBuilder(@"// <auto-generated />
namespace k8s.Models;
using k8s.Versioning;
");
var sbversion = new StringBuilder(@"// <auto-generated />
namespace k8s.Versioning;
using AutoMapper;
using k8s.Models;
public static partial class VersionConverter
{
private static void AutoConfigurations(IMapperConfigurationExpression cfg)
{
");
foreach (var(t0, t1) in versionConverterPairs)
{
sbmodel.AppendLine($@"
public partial class {t0}
{{
public static explicit operator {t0}({t1} s) => VersionConverter.Mapper.Map<{t0}>(s);
}}
public partial class {t1}
{{
public static explicit operator {t1}({t0} s) => VersionConverter.Mapper.Map<{t1}>(s);
}}");
sbversion.AppendLine($@"cfg.CreateMap<{t0}, {t1}>().ReverseMap();");
}
sbversion.AppendLine("}}");
context.AddSource($"ModelOperators.g.cs", SourceText.From(sbmodel.ToString(), Encoding.UTF8));
context.AddSource($"VersionConverter.g.cs", SourceText.From(sbversion.ToString(), Encoding.UTF8));
}
