internal string FromAssemblyType(string[] classNames, string settingsData)
{
var settings = JsonConvert.DeserializeObject<AssemblyTypeToSwaggerGeneratorSettings>(settingsData);
var generator = new JsonSchemaGenerator(settings);
var resolver = new SchemaResolver();
var service = new SwaggerService();
var assembly = Assembly.LoadFrom(settings.AssemblyPath);
foreach (var className in classNames)
{
var type = assembly.GetType(className);
var schema = generator.Generate<JsonSchema4>(type, resolver);
service.Definitions[type.Name] = schema;
}
return service.ToJson();
}
internal string FromAssemblyType(string[] classNames, string settingsData)
{
var document = new SwaggerDocument();
var settings = JsonConvert.DeserializeObject<AssemblyTypeToSwaggerGeneratorSettings>(settingsData);
RegisterReferencePaths(GetAllReferencePaths(settings));
var generator = new JsonSchemaGenerator(settings);
var schemaResolver = new SwaggerSchemaResolver(document, settings);
#if FullNet
var assembly = Assembly.LoadFrom(settings.AssemblyPath);
#else
var assembly = Context.LoadFromAssemblyPath(settings.AssemblyPath);
#endif
foreach (var className in classNames)
{
var type = assembly.GetType(className);
var schema = generator.Generate(type, schemaResolver);
document.Definitions[type.Name] = schema;
}
return document.ToJson();
}
/// <summary>
/// Generate the an operation of an AsyncApi Channel for the given method.
/// </summary>
private static Operation GenerateOperationFromMethod(MethodInfo method, AsyncApiSchemaResolver schemaResolver, OperationType operationType, AsyncApiOptions options, JsonSchemaGenerator jsonSchemaGenerator, IServiceProvider serviceProvider)
{
var operationAttribute = GetOperationAttribute(method, operationType);
if (operationAttribute == null)
{
return(null);
}
IEnumerable <MessageAttribute> messageAttributes = method.GetCustomAttributes <MessageAttribute>();
var message = messageAttributes.Any()
? GenerateMessageFromAttributes(messageAttributes, schemaResolver, jsonSchemaGenerator)
: GenerateMessageFromType(operationAttribute.MessagePayloadType, schemaResolver, jsonSchemaGenerator);
var operation = new Operation
{
OperationId = operationAttribute.OperationId ?? method.Name,
Summary = operationAttribute.Summary ?? method.GetXmlDocsSummary(),
Description = operationAttribute.Description ?? (method.GetXmlDocsRemarks() != "" ? method.GetXmlDocsRemarks() : null),
Message = message,
Bindings = operationAttribute.BindingsRef != null ? new OperationBindingsReference(operationAttribute.BindingsRef) : null,
};
var filterContext = new OperationFilterContext(method, schemaResolver, jsonSchemaGenerator, operationAttribute);
foreach (var filterType in options.OperationFilters)
{
var filter = (IOperationFilter)serviceProvider.GetRequiredService(filterType);
filter?.Apply(operation, filterContext);
}
return(operation);
}
public void GenerateSchemaSerializable()
{
JsonSchemaGenerator generator = new JsonSchemaGenerator();
generator.ContractResolver = new DefaultContractResolver
{
IgnoreSerializableAttribute = false
};
generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
JsonSchema schema = generator.Generate(typeof(Version), true);
string json = schema.ToString();
Assert.AreEqual(@"{
""id"": ""System.Version"",
""type"": [
""object"",
""null""
],
""additionalProperties"": false,
""properties"": {
""_Major"": {
""required"": true,
""type"": ""integer""
},
""_Minor"": {
""required"": true,
""type"": ""integer""
},
""_Build"": {
""required"": true,
""type"": ""integer""
},
""_Revision"": {
""required"": true,
""type"": ""integer""
}
}
}", json);
JTokenWriter jsonWriter = new JTokenWriter();
JsonSerializer serializer = new JsonSerializer();
serializer.ContractResolver = new DefaultContractResolver
{
IgnoreSerializableAttribute = false
};
serializer.Serialize(jsonWriter, new Version(1, 2, 3, 4));
List <string> errors = new List <string>();
jsonWriter.Token.Validate(schema, (sender, args) => errors.Add(args.Message));
Assert.AreEqual(0, errors.Count);
Assert.AreEqual(@"{
""_Major"": 1,
""_Minor"": 2,
""_Build"": 3,
""_Revision"": 4
}", jsonWriter.Token.ToString());
Version version = jsonWriter.Token.ToObject <Version>(serializer);
Assert.AreEqual(1, version.Major);
Assert.AreEqual(2, version.Minor);
Assert.AreEqual(3, version.Build);
Assert.AreEqual(4, version.Revision);
}
/// <summary>Initializes a new instance of the <see cref="SwaggerGenerator"/> class.</summary>
/// <param name="schemaGenerator">The schema generator.</param>
/// <param name="schemaGeneratorSettings">The schema generator settings.</param>
/// <param name="schemaResolver">The schema resolver.</param>
public SwaggerGenerator(JsonSchemaGenerator schemaGenerator, JsonSchemaGeneratorSettings schemaGeneratorSettings, JsonSchemaResolver schemaResolver)
{
_schemaResolver = schemaResolver;
_schemaGenerator = schemaGenerator;
_settings = schemaGeneratorSettings;
}
public static FileContent GetFile(string requestPath, JsonRpcInfo info)
{
var basePath = info?.JsonRpcApiEndpoint ?? "/jsonrpc";
string filePath;
if (!basePath.StartsWith("/"))
{
basePath = "/" + basePath;
}
if (!requestPath.StartsWith(basePath))
{
return(new FileContent());
}
if (requestPath.EndsWith("/"))
{
requestPath = requestPath.Substring(0, requestPath.Length - 1);
}
if (requestPath.EndsWith("jsonRpcApi.json"))
{
var jsonRpcDoc = DocGenerator.GenerateJsonRpcDoc(info);
var schemaSettings = new JsonSchemaGeneratorSettings
{
SerializerSettings = JsonSerializerSettings,
GenerateExamples = true,
SchemaType = SchemaType.JsonSchema,
GenerateAbstractSchemas = false,
DefaultReferenceTypeNullHandling = ReferenceTypeNullHandling.NotNull
};
var schema = new JsonSchema();
var resolver = new JsonSchemaResolver(schema, schemaSettings);
var generator = new JsonSchemaGenerator(schemaSettings);
generator.Generate(schema, typeof(object), resolver);
var jDoc = JObject.FromObject(jsonRpcDoc);
// generate schema definitions
foreach (var rpcService in jsonRpcDoc.Services)
{
foreach (var rpcMethod in rpcService.Methods)
{
if (rpcMethod.Response.Type != typeof(void) && rpcMethod.Response.Type != typeof(Task))
{
generator.Generate(rpcMethod.Response.Type, resolver);
}
foreach (var rpcMethodParameter in rpcMethod.Parameters)
{
generator.Generate(rpcMethodParameter.Type, resolver);
}
}
foreach (var notification in rpcService.Notifications)
{
foreach (var parameter in notification.Parameters)
{
generator.Generate(parameter.Type, resolver);
}
}
}
var schemaJObject = JObject.Parse(schema.ToJson());
jDoc["definitions"] = schemaJObject["definitions"];
var buffer = Encoding.UTF8.GetBytes(jDoc.ToString(Formatting.None));
var fileResult = new FileContent(requestPath, buffer);
return(fileResult);
}
if (requestPath.Equals(basePath))
{
filePath = "index.html";
}
else
{
filePath = requestPath.Substring(basePath.Length + 1);
filePath = filePath.Replace("/", ".");
}
var embeddedResource = $"{typeof(JsonRpcDoc).Namespace}.web.{filePath}";
using (var stream = typeof(JsonRpcDoc).Assembly.GetManifestResourceStream(embeddedResource))
{
byte[] buffer = null;
if (stream != null)
{
buffer = ReadToEnd(stream);
}
var fileResult = new FileContent(filePath, buffer);
return(fileResult);
}
}
private async Task <SigSpecOperation> GenerateOperationAsync(Type type, MethodInfo method, JsonSchemaGenerator generator, SigSpecSchemaResolver resolver, SigSpecOperationType operationType)
{
var operation = new SigSpecOperation
{
Description = method.GetXmlDocsSummary(),
Type = operationType
};
foreach (var arg in method.GetParameters())
{
var parameter = generator.GenerateWithReferenceAndNullability <SigSpecParameter>(
arg.ParameterType.ToContextualType(), arg.ParameterType.ToContextualType().IsNullableType, resolver, (p, s) =>
{
p.Description = arg.GetXmlDocs();
});
operation.Parameters[arg.Name] = parameter;
}
var returnType =
operationType == SigSpecOperationType.Observable
? method.ReturnType.GetGenericArguments().First()
: method.ReturnType == typeof(Task)
? null
: method.ReturnType.IsGenericType && method.ReturnType.BaseType == typeof(Task)
? method.ReturnType.GetGenericArguments().First()
: method.ReturnType;
operation.ReturnType = returnType == null ? null : generator.GenerateWithReferenceAndNullability <JsonSchema>(
returnType.ToContextualType(), returnType.ToContextualType().IsNullableType, resolver, async(p, s) =>
{
p.Description = method.ReturnType.GetXmlDocsSummary();
});
return(operation);
}
private static IMessage GenerateMessageFromAttributes(IEnumerable <MessageAttribute> messageAttributes, AsyncApiSchemaResolver schemaResolver, JsonSchemaGenerator jsonSchemaGenerator)
{
if (messageAttributes.Count() == 1)
{
return(GenerateMessageFromAttribute(messageAttributes.First(), schemaResolver, jsonSchemaGenerator));
}
var messages = new Messages();
foreach (MessageAttribute messageAttribute in messageAttributes)
{
var message = GenerateMessageFromAttribute(messageAttribute, schemaResolver, jsonSchemaGenerator);
if (message != null)
{
messages.OneOf.Add(message);
}
}
if (messages.OneOf.Count == 1)
{
return(messages.OneOf.First());
}
return(messages);
}
private static SwaggerDocument CreateService()
{
var document = new SwaggerDocument();
var settings = new JsonSchemaGeneratorSettings();
var generator = new JsonSchemaGenerator(settings);
document.Paths["/Person"] = new SwaggerOperations();
document.Paths["/Person"][SwaggerOperationMethod.Get] = new SwaggerOperation
{
Responses = new Dictionary<string, SwaggerResponse>
{
{
"200", new SwaggerResponse
{
Schema = new JsonSchema4
{
SchemaReference = generator.Generate(typeof(Person), new SwaggerSchemaResolver(document, settings))
}
}
}
}
};
return document;
}
public uSyncSchemaGenerator()
{
_schemaGenerator = new JsonSchemaGenerator(new uSyncSchemaGeneratorSettings());
}
public SchemaCustomizerArgs(string name, PropertyInfo typeProperty, JsonProperty schemaProperty, JsonSchema4 schema, JsonSchemaGenerator schemaGenerator, Type type)
{
this.Name = name;
this.TypeProperty = typeProperty;
this.SchemaProperty = schemaProperty;
this.Schema = schema;
this.SchemaGenerator = schemaGenerator;
this.Type = type;
}
/// <summary>
/// Generate the Channels section of an AsyncApi schema.
/// </summary>
private static IDictionary <string, ChannelItem> GenerateChannels(TypeInfo[] asyncApiTypes, AsyncApiSchemaResolver schemaResolver, AsyncApiOptions options, JsonSchemaGenerator jsonSchemaGenerator, IServiceProvider serviceProvider)
{
var channels = new Dictionary <string, ChannelItem>();
channels.AddRange(GenerateChannelsFromMethods(asyncApiTypes, schemaResolver, options, jsonSchemaGenerator, serviceProvider));
channels.AddRange(GenerateChannelsFromClasses(asyncApiTypes, schemaResolver, options, jsonSchemaGenerator, serviceProvider));
return(channels);
}
/// <summary>
/// Generate the Channels section of the AsyncApi schema from the
/// <see cref="ChannelAttribute"/> on methods.
/// </summary>
private static IDictionary <string, ChannelItem> GenerateChannelsFromMethods(IEnumerable <TypeInfo> asyncApiTypes, AsyncApiSchemaResolver schemaResolver, AsyncApiOptions options, JsonSchemaGenerator jsonSchemaGenerator, IServiceProvider serviceProvider)
{
var channels = new Dictionary <string, ChannelItem>();
var methodsWithChannelAttribute = asyncApiTypes
.SelectMany(type => type.DeclaredMethods)
.Select(method => new
{
Channel = method.GetCustomAttribute <ChannelAttribute>(),
Method = method,
})
.Where(mc => mc.Channel != null);
foreach (var mc in methodsWithChannelAttribute)
{
var channelItem = new ChannelItem
{
Description = mc.Channel.Description,
Parameters = GetChannelParametersFromAttributes(mc.Method, schemaResolver, jsonSchemaGenerator),
Publish = GenerateOperationFromMethod(mc.Method, schemaResolver, OperationType.Publish, options, jsonSchemaGenerator, serviceProvider),
Subscribe = GenerateOperationFromMethod(mc.Method, schemaResolver, OperationType.Subscribe, options, jsonSchemaGenerator, serviceProvider),
Bindings = mc.Channel.BindingsRef != null ? new ChannelBindingsReference(mc.Channel.BindingsRef) : null,
Servers = mc.Channel.Servers?.ToList(),
};
channels.Add(mc.Channel.Name, channelItem);
var context = new ChannelItemFilterContext(mc.Method, schemaResolver, jsonSchemaGenerator, mc.Channel);
foreach (var filterType in options.ChannelItemFilters)
{
var filter = (IChannelItemFilter)serviceProvider.GetRequiredService(filterType);
filter.Apply(channelItem, context);
}
}
return(channels);
}
private static IDictionary <string, IParameter> GetChannelParametersFromAttributes(MemberInfo memberInfo, AsyncApiSchemaResolver schemaResolver, JsonSchemaGenerator jsonSchemaGenerator)
{
IEnumerable <ChannelParameterAttribute> attributes = memberInfo.GetCustomAttributes <ChannelParameterAttribute>();
var parameters = new Dictionary <string, IParameter>();
if (attributes.Any())
{
foreach (ChannelParameterAttribute attribute in attributes)
{
var parameter = schemaResolver.GetParameterOrReference(new Parameter
{
Description = attribute.Description,
Name = attribute.Name,
Schema = jsonSchemaGenerator.Generate(attribute.Type, schemaResolver),
Location = attribute.Location,
});
parameters.Add(attribute.Name, parameter);
}
}
return(parameters);
}
private static IMessage GenerateMessageFromType(Type payloadType, AsyncApiSchemaResolver schemaResolver, JsonSchemaGenerator jsonSchemaGenerator)
{
if (payloadType == null)
{
return(null);
}
var message = new Message
{
Payload = jsonSchemaGenerator.Generate(payloadType, schemaResolver),
};
message.Name = message.Payload.Id;
return(schemaResolver.GetMessageOrReference(message));
}
private static IMessage GenerateMessageFromAttribute(MessageAttribute messageAttribute, AsyncApiSchemaResolver schemaResolver, JsonSchemaGenerator jsonSchemaGenerator)
{
if (messageAttribute?.PayloadType == null)
{
return(null);
}
var message = new Message
{
Payload = jsonSchemaGenerator.Generate(messageAttribute.PayloadType, schemaResolver),
Title = messageAttribute.Title,
Summary = messageAttribute.Summary,
Description = messageAttribute.Description,
Bindings = messageAttribute.BindingsRef != null ? new MessageBindingsReference(messageAttribute.BindingsRef) : null,
};
message.Name = messageAttribute.Name ?? message.Payload.ActualSchema.Id;
return(schemaResolver.GetMessageOrReference(message));
}
public static async Task <JsonSchema4> GetErrorDtoSchemaAsync(this JsonSchemaGenerator schemaGenerator, JsonSchemaResolver resolver)
{
var errorType = typeof(ErrorDto);
return(await schemaGenerator.GenerateWithReference <JsonSchema4>(errorType, Enumerable.Empty <Attribute>(), resolver));
}
public void CircularReferenceError()
{
JsonSchemaGenerator generator = new JsonSchemaGenerator();
generator.Generate(typeof(CircularReferenceClass));
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
/// <exception cref="Exception">exception thrown
/// </exception>
public static void Main(string[] args)
{
if (!args.Any())
{
throw new Exception("Please pass the job.xml file as a parameter");
}
if (args[0] == "-generateschema")
{
if (args.Length < 2 || string.IsNullOrEmpty(args[1]))
{
throw new Exception("You must specify a valid filename to write the schema to.");
}
var filename = args[1];
JsonSchemaGenerator.WriteSchemaToFile(typeof(QueryConfig), filename);
Console.WriteLine($"Written schema to {filename}");
return;
}
string inputFile = args[0];
var config = new ConfigReader().ReadXml(inputFile);
var stopwatch = new Stopwatch();
stopwatch.Start();
ILogger logger = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.File(Path.Combine(Path.GetTempPath(), "Databus.out.txt"))
.CreateLogger();
using (ProgressMonitor progressMonitor = new ProgressMonitor(new ConsoleProgressLogger()))
{
using (var cancellationTokenSource = new CancellationTokenSource())
{
var container = new UnityContainer();
container.RegisterInstance <IProgressMonitor>(progressMonitor);
var databusSqlReader = new DatabusSqlReader(config.Config.ConnectionString, 0);
container.RegisterInstance <IDatabusSqlReader>(databusSqlReader);
container.RegisterType <IElasticSearchUploaderFactory, ElasticSearchUploaderFactory>();
container.RegisterType <IFileUploaderFactory, FileUploaderFactory>();
container.RegisterType <IElasticSearchUploader, ElasticSearchUploader>();
container.RegisterType <IFileUploader, FileUploader>();
container.RegisterType <IHttpClientFactory, HttpClientFactory>();
container.RegisterInstance(logger);
if (config.Config.UseMultipleThreads)
{
container.RegisterType <IPipelineExecutorFactory, MultiThreadedPipelineExecutorFactory>();
}
else
{
container.RegisterType <IPipelineExecutorFactory, SingleThreadedPipelineExecutorFactory>();
}
var pipelineRunner = new DatabusRunner();
if (config.Config.UploadToElasticSearch)
{
pipelineRunner.RunElasticSearchPipeline(container, config, cancellationTokenSource.Token);
}
else
{
pipelineRunner.RunRestApiPipeline(container, config, cancellationTokenSource.Token);
}
}
}
stopwatch.Stop();
var timeElapsed = stopwatch.Elapsed.ToString(@"hh\:mm\:ss");
var threadText = config.Config.UseMultipleThreads ? "multiple threads" : "single thread";
Console.WriteLine($"Finished in {timeElapsed} using {threadText}");
#if TRUE
logger.Verbose("Finished in {ElapsedMinutes} minutes on {Date}.", stopwatch.Elapsed.TotalMinutes, DateTime.Today);
//logger.Error(new Exception("test"), "An error has occurred.");
Log.CloseAndFlush();
//file.Flush();
//file.Close();
//file.Dispose();
//file = null;
#endif
Console.WriteLine("(Type any key to exit)");
Console.ReadKey();
}
/// <summary>
/// Generate the an operation of an AsyncApi Channel for the given class.
/// </summary>
private static Operation GenerateOperationFromClass(TypeInfo type, AsyncApiSchemaResolver schemaResolver, OperationType operationType, JsonSchemaGenerator jsonSchemaGenerator)
{
var operationAttribute = GetOperationAttribute(type, operationType);
if (operationAttribute == null)
{
return(null);
}
var messages = new Messages();
var operation = new Operation
{
OperationId = operationAttribute.OperationId ?? type.Name,
Summary = operationAttribute.Summary ?? type.GetXmlDocsSummary(),
Description = operationAttribute.Description ?? (type.GetXmlDocsRemarks() != "" ? type.GetXmlDocsRemarks() : null),
Message = messages,
Bindings = operationAttribute.BindingsRef != null ? new OperationBindingsReference(operationAttribute.BindingsRef) : null,
};
var methodsWithMessageAttribute = type.DeclaredMethods
.Select(method => new
{
MessageAttributes = method.GetCustomAttributes <MessageAttribute>(),
Method = method,
})
.Where(mm => mm.MessageAttributes.Any());
foreach (MessageAttribute messageAttribute in methodsWithMessageAttribute.SelectMany(x => x.MessageAttributes))
{
var message = GenerateMessageFromAttribute(messageAttribute, schemaResolver, jsonSchemaGenerator);
if (message != null)
{
messages.OneOf.Add(message);
}
}
if (messages.OneOf.Count == 1)
{
operation.Message = messages.OneOf.First();
}
return(operation);
}
/// <summary>Initializes a new instance of the <see cref="SwaggerGenerator"/> class.</summary>
/// <param name="schemaGenerator">The schema generator.</param>
/// <param name="schemaGeneratorSettings">The schema generator settings.</param>
/// <param name="schemaResolver">The schema resolver.</param>
public SwaggerGenerator(JsonSchemaGenerator schemaGenerator, JsonSchemaGeneratorSettings schemaGeneratorSettings, JsonSchemaResolver schemaResolver)
{
_schemaGenerator = schemaGenerator;
_schemaResolver = schemaResolver;
_settings = schemaGeneratorSettings;
}
/// <summary>Initializes a new instance of the <see cref="AspNetCoreOperationProcessorContext" /> class.</summary>
/// <param name="document">The document.</param>
/// <param name="operationDescription">The operation description.</param>
/// <param name="controllerType">Type of the controller.</param>
/// <param name="methodInfo">The method information.</param>
/// <param name="swaggerGenerator">The swagger generator.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <param name="allOperationDescriptions">All operation descriptions.</param>
/// <param name="schemaGenerator">The schema generator.</param>
public AspNetCoreOperationProcessorContext(SwaggerDocument document, SwaggerOperationDescription operationDescription, Type controllerType, MethodInfo methodInfo, SwaggerGenerator swaggerGenerator, JsonSchemaGenerator schemaGenerator, JsonSchemaResolver schemaResolver, IList <SwaggerOperationDescription> allOperationDescriptions)
: base(document, operationDescription, controllerType, methodInfo, swaggerGenerator, schemaGenerator, schemaResolver, allOperationDescriptions)
{
}
/// <summary>Initializes a new instance of the <see cref="DocumentProcessorContext" /> class.</summary>
/// <param name="document">The document.</param>
/// <param name="controllerTypes">The controller types.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <param name="schemaGenerator">The schema generator.</param>
public DocumentProcessorContext(SwaggerDocument document, IEnumerable <Type> controllerTypes, JsonSchemaResolver schemaResolver, JsonSchemaGenerator schemaGenerator)
{
Document = document;
ControllerTypes = controllerTypes;
SchemaResolver = schemaResolver;
SchemaGenerator = schemaGenerator;
}
/// <summary>Creates a <see cref="JsonSchema4" /> from a given type.</summary>
/// <typeparam name="TType">The type to create the schema for.</typeparam>
/// <param name="settings">The settings.</param>
/// <returns>The <see cref="JsonSchema4" />.</returns>
public static async Task <JsonSchema4> FromTypeAsync <TType>(JsonSchemaGeneratorSettings settings)
{
var generator = new JsonSchemaGenerator(settings);
return(await generator.GenerateAsync(typeof(TType)).ConfigureAwait(false));
}
public DocumentFilterContext(IEnumerable <Type> asyncApiTypes, JsonSchemaResolver schemaResolver, JsonSchemaGenerator schemaGenerator)
{
AsyncApiTypes = asyncApiTypes;
SchemaResolver = schemaResolver;
SchemaGenerator = schemaGenerator;
}
public JsonParameterValidationHelper()
{
_jsonSchemaGenerator = new JsonSchemaGenerator();
}
private async Task <SigSpecOperation> GenerateOperationAsync(Type type, MethodInfo method, JsonSchemaGenerator generator, SigSpecSchemaResolver resolver, SigSpecOperationType operationType)
{
var operation = new SigSpecOperation
{
Description = await type.GetXmlSummaryAsync(),
Type = operationType
};
foreach (var arg in method.GetParameters())
{
var parameter = await generator.GenerateWithReferenceAndNullabilityAsync <SigSpecParameter>(
arg.ParameterType, arg.GetCustomAttributes(), resolver, async (p, s) =>
{
p.Description = await arg.GetXmlDocumentationAsync();
});
operation.Parameters[arg.Name] = parameter;
}
var returnType =
operationType == SigSpecOperationType.Observable
? method.ReturnType.GetGenericTypeArguments().First()
: method.ReturnType == typeof(Task)
? null
: method.ReturnType.IsGenericType && method.ReturnType.BaseType == typeof(Task)
? method.ReturnType.GetGenericTypeArguments().First()
: method.ReturnType;
operation.ReturnType = returnType == null ? null : await generator.GenerateWithReferenceAndNullabilityAsync <JsonSchema4>(
returnType, null, resolver, async (p, s) =>
{
p.Description = await method.ReturnType.GetXmlSummaryAsync();
});
return(operation);
}
/// <summary>Gets the schema for the mapped type.</summary>
/// <typeparam name="TSchemaType">The type of the schema type.</typeparam>
/// <param name="schema">The schema.</param>
/// <param name="schemaGenerator">The schema generator.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <returns>The schema.</returns>
#pragma warning disable 1998
public async Task GenerateSchemaAsync <TSchemaType>(TSchemaType schema, JsonSchemaGenerator schemaGenerator, JsonSchemaResolver schemaResolver)
#pragma warning restore 1998
where TSchemaType : JsonSchema4, new()
{
_transformer(schema);
}
public void GenerateSchemaForDirectoryInfo()
{
JsonSchemaGenerator generator = new JsonSchemaGenerator();
generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
generator.ContractResolver = new CustomDirectoryInfoMapper
{
#if !(NETFX_CORE || PORTABLE)
IgnoreSerializableAttribute = true
#endif
};
JsonSchema schema = generator.Generate(typeof(DirectoryInfo), true);
string json = schema.ToString();
Assert.AreEqual(@"{
""id"": ""System.IO.DirectoryInfo"",
""required"": true,
""type"": [
""object"",
""null""
],
""additionalProperties"": false,
""properties"": {
""Name"": {
""required"": true,
""type"": [
""string"",
""null""
]
},
""Parent"": {
""$ref"": ""System.IO.DirectoryInfo""
},
""Exists"": {
""required"": true,
""type"": ""boolean""
},
""FullName"": {
""required"": true,
""type"": [
""string"",
""null""
]
},
""Extension"": {
""required"": true,
""type"": [
""string"",
""null""
]
},
""CreationTime"": {
""required"": true,
""type"": ""string""
},
""CreationTimeUtc"": {
""required"": true,
""type"": ""string""
},
""LastAccessTime"": {
""required"": true,
""type"": ""string""
},
""LastAccessTimeUtc"": {
""required"": true,
""type"": ""string""
},
""LastWriteTime"": {
""required"": true,
""type"": ""string""
},
""LastWriteTimeUtc"": {
""required"": true,
""type"": ""string""
},
""Attributes"": {
""required"": true,
""type"": ""integer""
}
}
}", json);
DirectoryInfo temp = new DirectoryInfo(@"c:\temp");
JTokenWriter jsonWriter = new JTokenWriter();
JsonSerializer serializer = new JsonSerializer();
serializer.Converters.Add(new IsoDateTimeConverter());
serializer.ContractResolver = new CustomDirectoryInfoMapper
{
#if !(NETFX_CORE || PORTABLE)
IgnoreSerializableInterface = true
#endif
};
serializer.Serialize(jsonWriter, temp);
List <string> errors = new List <string>();
jsonWriter.Token.Validate(schema, (sender, args) => errors.Add(args.Message));
Assert.AreEqual(0, errors.Count);
}
/// <summary>Initializes a new instance of the <see cref="SchemaProcessorContext" /> class.</summary>
/// <param name="schema">The JSON Schema.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="generator">The generator.</param>
public SchemaProcessorContext(JsonSchema4 schema, JsonSchemaResolver resolver, JsonSchemaGenerator generator)
{
Schema = schema;
Resolver = resolver;
Generator = generator;
}
public void JsonPropertyWithHandlingValues()
{
JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator();
jsonSchemaGenerator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
JsonSchema jsonSchema = jsonSchemaGenerator.Generate(typeof(JsonPropertyWithHandlingValues));
string json = jsonSchema.ToString();
Assert.AreEqual(@"{
""id"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues"",
""required"": true,
""type"": [
""object"",
""null""
],
""properties"": {
""DefaultValueHandlingIgnoreProperty"": {
""type"": [
""string"",
""null""
],
""default"": ""Default!""
},
""DefaultValueHandlingIncludeProperty"": {
""required"": true,
""type"": [
""string"",
""null""
],
""default"": ""Default!""
},
""DefaultValueHandlingPopulateProperty"": {
""required"": true,
""type"": [
""string"",
""null""
],
""default"": ""Default!""
},
""DefaultValueHandlingIgnoreAndPopulateProperty"": {
""type"": [
""string"",
""null""
],
""default"": ""Default!""
},
""NullValueHandlingIgnoreProperty"": {
""type"": [
""string"",
""null""
]
},
""NullValueHandlingIncludeProperty"": {
""required"": true,
""type"": [
""string"",
""null""
]
},
""ReferenceLoopHandlingErrorProperty"": {
""$ref"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues""
},
""ReferenceLoopHandlingIgnoreProperty"": {
""$ref"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues""
},
""ReferenceLoopHandlingSerializeProperty"": {
""$ref"": ""Newtonsoft.Json.Tests.TestObjects.JsonPropertyWithHandlingValues""
}
}
}", json);
}
/// <summary>
/// The main entry point.
/// </summary>
/// <param name="args">The console arguments.</param>
/// <returns>A statuc code.</returns>
public static async Task <int> Main(string[] args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
Logger.Default = new ColoredConsoleLogger(nameof(CodeGenConsole));
// Check for special case / internal use arguments.
if (args.Length == 1)
{
switch (args[0].ToUpperInvariant())
{
case "--GENERATEENTITYXMLSCHEMA": return(SpecialActivitiesCenter("Generate Entity XML Schema", "./Schema/codegen.entity.xsd", fn => XmlSchemaGenerator.Create <Config.Entity.CodeGenConfig>(ConfigType.Entity).Save(fn, System.Xml.Linq.SaveOptions.None)));
case "--GENERATEENTITYJSONSCHEMA": return(SpecialActivitiesCenter("Generate Entity JSON Schema", "./Schema/entity.beef.json", fn => File.WriteAllText(fn, JsonSchemaGenerator.Create <Config.Entity.CodeGenConfig>("JSON Schema for Beef Entity code-generation (https://github.com/Avanade/Beef)."))));
case "--GENERATEDATABASEXMLSCHEMA": return(SpecialActivitiesCenter("Generate Database XML Schema", "./Schema/codegen.table.xsd", fn => XmlSchemaGenerator.Create <Config.Database.CodeGenConfig>(ConfigType.Database).Save(fn, System.Xml.Linq.SaveOptions.None)));
case "--GENERATEDATABASEJSONSCHEMA": return(SpecialActivitiesCenter("Generate Database JSON Schema", "./Schema/database.beef.json", fn => File.WriteAllText(fn, JsonSchemaGenerator.Create <Config.Database.CodeGenConfig>("JSON Schema for Beef Database code-generation (https://github.com/Avanade/Beef)."))));
case "--GENERATEENTITYMARKDOWN": return(SpecialActivitiesCenter("Generate Entity YAML documentation markdown file(s)", "../../docs/", fn => SchemaMarkdownGenerator.Create <Config.Entity.CodeGenConfig>(fn, ConfigType.Entity, true)));
case "--GENERATEENTITYXMLMARKDOWN": return(SpecialActivitiesCenter("Generate Entity XML documentation markdown file(s)", "../../docs/", fn => SchemaMarkdownGenerator.Create <Config.Entity.CodeGenConfig>(fn, ConfigType.Entity, false)));
case "--GENERATEDATABASEMARKDOWN": return(SpecialActivitiesCenter("Generate Database YAML documentation markdown file(s)", "../../docs/", fn => SchemaMarkdownGenerator.Create <Config.Database.CodeGenConfig>(fn, ConfigType.Database, true)));
case "--GENERATEDATABASEXMLMARKDOWN": return(SpecialActivitiesCenter("Generate Database XML documentation markdown file(s)", "../../docs/", fn => SchemaMarkdownGenerator.Create <Config.Database.CodeGenConfig>(fn, ConfigType.Database, false)));
}
}
return(await CodeGenConsole.Create().RunAsync(args).ConfigureAwait(false));
}
public void GenerateSchemaSerializable()
{
JsonSchemaGenerator generator = new JsonSchemaGenerator();
DefaultContractResolver contractResolver = new DefaultContractResolver
{
IgnoreSerializableAttribute = false
};
generator.ContractResolver = contractResolver;
generator.UndefinedSchemaIdHandling = UndefinedSchemaIdHandling.UseTypeName;
JsonSchema schema = generator.Generate(typeof(SerializableTestObject), true);
string json = schema.ToString();
StringAssert.AreEqual(
@"{
""id"": ""Newtonsoft.Json.Tests.Schema.SerializableTestObject"",
""type"": [
""object"",
""null""
],
""additionalProperties"": false,
""properties"": {
""_name"": {
""required"": true,
""type"": [
""string"",
""null""
]
}
}
}",
json
);
JTokenWriter jsonWriter = new JTokenWriter();
JsonSerializer serializer = new JsonSerializer();
serializer.ContractResolver = contractResolver;
serializer.Serialize(jsonWriter, new SerializableTestObject {
Name = "Name!"
});
List <string> errors = new List <string>();
jsonWriter.Token.Validate(schema, (sender, args) => errors.Add(args.Message));
Assert.AreEqual(0, errors.Count);
StringAssert.AreEqual(
@"{
""_name"": ""Name!""
}",
jsonWriter.Token.ToString()
);
SerializableTestObject c = jsonWriter.Token.ToObject <SerializableTestObject>(
serializer
);
Assert.AreEqual("Name!", c.Name);
}
/// <summary>
/// Generate the Channels section of the AsyncApi schema from the
/// <see cref="ChannelAttribute"/> on classes.
/// </summary>
private static IDictionary <string, ChannelItem> GenerateChannelsFromClasses(IEnumerable <TypeInfo> asyncApiTypes, AsyncApiSchemaResolver schemaResolver, AsyncApiOptions options, JsonSchemaGenerator jsonSchemaGenerator, IServiceProvider serviceProvider)
{
var channels = new Dictionary <string, ChannelItem>();
var classesWithChannelAttribute = asyncApiTypes
.Select(type => new
{
Channel = type.GetCustomAttribute <ChannelAttribute>(),
Type = type,
})
.Where(cc => cc.Channel != null);
foreach (var cc in classesWithChannelAttribute)
{
var channelItem = new ChannelItem
{
Description = cc.Channel.Description,
Parameters = GetChannelParametersFromAttributes(cc.Type, schemaResolver, jsonSchemaGenerator),
Publish = GenerateOperationFromClass(cc.Type, schemaResolver, OperationType.Publish, jsonSchemaGenerator),
Subscribe = GenerateOperationFromClass(cc.Type, schemaResolver, OperationType.Subscribe, jsonSchemaGenerator),
Bindings = cc.Channel.BindingsRef != null ? new ChannelBindingsReference(cc.Channel.BindingsRef) : null,
Servers = cc.Channel.Servers?.ToList(),
};
channels.AddOrAppend(cc.Channel.Name, channelItem);
var context = new ChannelItemFilterContext(cc.Type, schemaResolver, jsonSchemaGenerator, cc.Channel);
foreach (var filterType in options.ChannelItemFilters)
{
var filter = (IChannelItemFilter)serviceProvider.GetRequiredService(filterType);
filter.Apply(channelItem, context);
}
}
return(channels);
}
