public async Task WithJsonSerializerSettingsSerDe()
{
const int value = 1234;
var expectedJson = $"{{\"Value\":{value * 2}}}";
var jsonSchemaGeneratorSettings = new JsonSchemaGeneratorSettings
{
SerializerSettings = new JsonSerializerSettings
{
Converters = new List <JsonConverter>
{
new UInt32ValueMultiplyConverter()
},
ContractResolver = new DefaultContractResolver()
}
};
var jsonSerializer = new JsonSerializer <UInt32Value>(schemaRegistryClient, jsonSchemaGeneratorSettings: jsonSchemaGeneratorSettings);
var jsonDeserializer = new JsonDeserializer <UInt32Value>(jsonSchemaGeneratorSettings: jsonSchemaGeneratorSettings);
var v = new UInt32Value {
Value = value
};
var bytes = await jsonSerializer.SerializeAsync(v, new SerializationContext(MessageComponentType.Value, testTopic));
Assert.NotNull(bytes);
Assert.Equal(expectedJson, Encoding.UTF8.GetString(bytes.AsSpan().Slice(5)));
var actual = await jsonDeserializer.DeserializeAsync(bytes, false, new SerializationContext(MessageComponentType.Value, testTopic));
Assert.NotNull(actual);
Assert.Equal(v.Value, actual.Value);
}
public async Task When_SerializerSettings_has_CamelCase_StringEnumConverter_then_enum_values_are_correct()
{
// Arrange
var settings = new JsonSchemaGeneratorSettings
{
SerializerSettings = new JsonSerializerSettings
{
Converters =
{
new StringEnumConverter {
CamelCaseText = true
}
}
}
};
// Act
var schema = await JsonSchema4.FromTypeAsync <MyEnum>(settings);
var json = schema.ToJson();
// Assert
Assert.Equal("value1", schema.Enumeration.First());
Assert.Equal("value2", schema.Enumeration.Last());
Assert.Equal("Value1", schema.EnumerationNames.First());
Assert.Equal("Value2", schema.EnumerationNames.Last());
}
public void When_generating_multiple_types_then_they_are_appended_to_the_definitions()
{
//// Arrange
var classNames = new[]
{
"NSwag.Generation.WebApi.Tests.B",
"NSwag.Generation.WebApi.Tests.C"
};
//// Act
var document = new OpenApiDocument();
var settings = new JsonSchemaGeneratorSettings();
var schemaResolver = new OpenApiSchemaResolver(document, settings);
var generator = new JsonSchemaGenerator(settings);
foreach (var className in classNames)
{
var type = typeof(TypesToSwaggerTests).Assembly.GetType(className);
generator.Generate(type, schemaResolver);
}
var json = document.ToJson();
//// Assert
Assert.IsNotNull(json);
Assert.AreEqual(2, document.Definitions.Count);
}
public async Task <IActionResult> GetContractsAsync()
{
var fetchFrom = new[]
{
typeof(Client),
typeof(IdentityResource),
typeof(ApiResource)
};
//var generator = new JSchemaGenerator {ContractResolver = new CamelCasePropertyNamesContractResolver()};
var schemas = new Dictionary <string, object>();
var generatorSettings = new JsonSchemaGeneratorSettings();
generatorSettings.SerializerSettings = new JsonSerializerSettings();
generatorSettings.FlattenInheritanceHierarchy = true;
generatorSettings.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
//generatorSettings.SerializerSettings.PreserveReferencesHandling =
// PreserveReferencesHandling.All;
foreach (var type in fetchFrom)
{
var schema = await JsonSchema4.FromTypeAsync(type, generatorSettings);
schemas.Add(ToLowerFirstLetter(type.Name), JsonConvert.DeserializeObject(schema.ToJson()));
}
return(Ok(schemas));
}
public JsonSchemaHandler()
{
var settings = new JsonSchemaGeneratorSettings {
};
_schemaGenerator = new JsonSchemaGenerator(settings);
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomResourceDefinitionGenerator"/> class.
/// </summary>
/// <param name="client">The client.</param>
public CustomResourceDefinitionGenerator()
{
_jsonSchemaGeneratorSettings = new JsonSchemaGeneratorSettings()
{
SchemaType = SchemaType.OpenApi3,
TypeMappers =
{
new ObjectTypeMapper(
typeof(V1ObjectMeta),
new JsonSchema
{
Type = JsonObjectType.Object,
}),
},
};
_serializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.None,
DateFormatHandling = DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = DateTimeZoneHandling.Utc,
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter(),
},
};
}
private static JsonSchema GenerateJsonSchema(Type type, JsonSchemaGeneratorSettings generatorSettings)
{
var jsonSchema4 = JsonSchema.FromType(type, generatorSettings);
jsonSchema4.Id = type.Name;
return(jsonSchema4);
}
private static void Main(string[] args)
{
string schemaFile = Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location), $"{nameof(Ncrement)}-schema.json".ToLowerInvariant());
if (args.Length > 0 && string.IsNullOrEmpty(args[0]) == false)
{
schemaFile = args[0];
}
string folder = Path.GetDirectoryName(schemaFile);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
var settings = new JsonSchemaGeneratorSettings()
{
ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver()
{
NamingStrategy = new Newtonsoft.Json.Serialization.CamelCaseNamingStrategy()
}
};
var generator = new JsonSchemaGenerator(settings);
var schema = generator.Generate(typeof(Manifest));
File.WriteAllText(schemaFile, schema.ToJson());
}
public JsonHelper()
{
jsonSerializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCaseExceptDictionaryKeysResolver()
};
jsonSerializerSettings.Formatting = Formatting.Indented;
jsonSchemaGeneratorSettings = new JsonSchemaGeneratorSettings
{
FlattenInheritanceHierarchy = true,
SchemaType = SchemaType.JsonSchema,
SchemaNameGenerator = new DefaultSchemaNameGenerator(),
SerializerSettings = jsonSerializerSettings
};
jsonSchemaGeneratorSettings.SchemaProcessors.Add(new InheritanceProcessor());
jsonSchemaGeneratorSettings.SchemaProcessors.Add(new GuidFixProcessor());
jsonSchemaGeneratorSettings.TypeMappers.Add(
new PrimitiveTypeMapper(typeof(DynamicData), schema =>
{
schema.Type = JsonObjectType.Object;
schema.AdditionalPropertiesSchema = new JsonSchema
{
Description = "Any"
};
}));
jsonSerializer = JsonSerializer.Create(jsonSerializerSettings);
}
public async Task When_discriminator_is_externally_defined_then_it_is_generated()
{
//// Arrange
var settings = new JsonSchemaGeneratorSettings
{
SchemaProcessors =
{
new DiscriminatorSchemaProcessor(typeof(CommonThingBase), "discriminator")
}
};
//// Act
var schema = await JsonSchema4.FromTypeAsync <ViewModelThing>(settings);
var data = schema.ToJson();
//// Assert
Assert.True(schema.Definitions.ContainsKey(nameof(CommonThingBase)));
Assert.True(schema.Definitions.ContainsKey(nameof(ACommonThing)));
Assert.True(schema.Definitions.ContainsKey(nameof(BCommonThing)));
var baseSchema = schema.Definitions[nameof(CommonThingBase)];
Assert.Equal("discriminator", baseSchema.Discriminator);
}
private AspNetCoreOperationProcessorContext GetContext(ApiDescription apiDescription)
{
var operationDescription = new SwaggerOperationDescription {
Operation = new SwaggerOperation()
};
var swaggerSettings = new AspNetCoreToSwaggerGeneratorSettings();
var document = new SwaggerDocument();
var generator = new AspNetCoreToSwaggerGenerator(swaggerSettings);
var schemaGeneratorSettings = new JsonSchemaGeneratorSettings();
var schemaGenerator = new JsonSchemaGenerator(schemaGeneratorSettings);
var schemaResolver = new SwaggerSchemaResolver(document, schemaGeneratorSettings);
var context = new AspNetCoreOperationProcessorContext(
document,
operationDescription,
GetType(),
GetType().GetMethod(nameof(SomeAction), BindingFlags.NonPublic | BindingFlags.Instance),
new SwaggerGenerator(schemaGenerator, schemaGeneratorSettings, schemaResolver),
schemaGenerator,
schemaResolver,
swaggerSettings,
new List <SwaggerOperationDescription>())
{
ApiDescription = apiDescription,
};
return(context);
}
private static void ConfigureSchemaSettings(JsonSchemaGeneratorSettings settings, bool flatten = false)
{
settings.AllowReferencesWithProperties = true;
settings.ReflectionService = new ReflectionServices();
settings.TypeMappers = new List <ITypeMapper>
{
CreateStringMap <DomainId>(),
CreateStringMap <Instant>(JsonFormatStrings.DateTime),
CreateStringMap <LocalDate>(JsonFormatStrings.Date),
CreateStringMap <LocalDateTime>(JsonFormatStrings.DateTime),
CreateStringMap <Language>(),
CreateStringMap <NamedId <DomainId> >(),
CreateStringMap <NamedId <Guid> >(),
CreateStringMap <NamedId <string> >(),
CreateStringMap <RefToken>(),
CreateStringMap <Status>(),
CreateObjectMap <JsonObject>(),
CreateObjectMap <AssetMetadata>()
};
settings.SchemaType = SchemaType.OpenApi3;
settings.FlattenInheritanceHierarchy = flatten;
}
public static OpenApiDocument GetOpenApiDocument(JsonSchemaGeneratorSettings settings, params string[] assemblyDllPaths)
{
string currentDirectory = DynamicApis.DirectoryGetCurrentDirectory();
Assembly[] assemblies = PathUtilities.ExpandFileWildcards(assemblyDllPaths)
.Select(path => Assembly.LoadFrom(PathUtilities.MakeAbsolutePath(path, currentDirectory))).ToArray();
return(GetOpenApiDocument(settings, assemblies));
}
/// <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>
/// <param name="schemaDefinitionAppender">The schema definition appender.</param>
public SwaggerGenerator(JsonSchemaGenerator schemaGenerator, JsonSchemaGeneratorSettings schemaGeneratorSettings,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
_schemaGenerator = schemaGenerator;
_schemaResolver = schemaResolver;
_schemaDefinitionAppender = schemaDefinitionAppender;
_settings = schemaGeneratorSettings;
}
public EndpointDocJsonSchemaGenerator(JsonSchemaGeneratorSettings settings, IValueProviderResolver valueProviders, ISchemaCustomizerResolver schemaCustomizers, IAutoTitleGenerator titleGenerator)
: base(settings)
{
this.settings = settings;
this.valueProviders = valueProviders;
this.schemaCustomizers = schemaCustomizers;
this.titleGenerator = titleGenerator;
}
public Task <JsonSchema4> GetJsonSchemaFromType <T>()
{
var settings = new JsonSchemaGeneratorSettings {
DefaultPropertyNameHandling = PropertyNameHandling.CamelCase, FlattenInheritanceHierarchy = true
};
return(JsonSchema4.FromTypeAsync <T>(settings));
}
public static List <OpenApiDocument> GetOpenApiDocumentSepareted(JsonSchemaGeneratorSettings settings, params Assembly[] assemblies)
{
List <string> allExportedClassNames =
assemblies.SelectMany(a => a.ExportedTypes)
.Select(t => t.FullName).ToList();
return(GetOpenApiDocumentSepareted(settings, assemblies, allExportedClassNames));
}
public void Given_Settings_When_Instantiated_Then_It_Should_Return_Values()
{
var settings = new JsonSchemaGeneratorSettings();
var instance = new SchemaBuilder(settings);
instance.Settings
.Should().NotBeNull()
.And.Be(settings);
}
public InheritanceValidator(
JArray objects,
JsonSchemaGeneratorSettings settings)
{
Settings = settings;
Objects = objects;
SetupSchemas();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.TryAddScoped <IGitCredentialsProvider, WindowsGitCredentialsProvider>();
services.AddEdity(o =>
{
Configuration.Bind("EditySettings", o);
o.Events.CustomizeBuildTasks = buildTasks =>
{
buildTasks.SetBuildTaskBuilder("PublishToGitRepo", s => new PublishToGitRepo(s, new WindowsGitCredentialsProvider()));
};
o.Events.CustomizeTools = tools =>
{
tools
.AddTool("updateConfigSchema", new ToolCommand("Update the schema file for this application's configuration.", async a =>
{
var json = await Configuration.CreateSchema();
File.WriteAllText("appsettings.schema.json", json);
}))
.AddTool("updateEditySchema", new ToolCommand("Update the schema for edity.json in the manual.", async a =>
{
var settings = new JsonSchemaGeneratorSettings()
{
FlattenInheritanceHierarchy = true,
DefaultPropertyNameHandling = PropertyNameHandling.CamelCase,
DefaultEnumHandling = EnumHandling.String,
};
var generator = new JsonSchemaGenerator(settings);
var schema = await generator.GenerateAsync(typeof(EdityProject));
File.WriteAllText("../Manual/edityschema.json", schema.ToJson());
}))
.AddTool("clone", new ToolCommand("Clone a git repo.", a => RepoTools.Clone(a, o)));
if (o.ProjectMode == ProjectMode.OneRepoPerUser)
{
tools.AddTool("pushmaster", new ToolCommand("Push a one repo per user shared repo to an origin. Only works in OneRepoPerUser mode.", a => RepoTools.PushMaster(a, o)));
}
};
});
services.AddAuthentication(AuthCoreSchemes.Bearer)
.AddCookie(AuthCoreSchemes.Bearer, o =>
{
o.LoginPath = "/edity/auth/login";
o.LogoutPath = "/edity/auth/logout";
});
services.AddLogging(o =>
{
o.AddConfiguration(Configuration.GetSection("Logging"))
.AddConsole()
.AddDebug();
});
}
/// <summary>Initializes a new instance of the <see cref="OpenApiDocumentSchemaResolver" /> class.</summary>
/// <param name="document">The Open API document.</param>
/// <param name="settings">The settings.</param>
public OpenApiDocumentSchemaResolver(OpenApiDocument document, JsonSchemaGeneratorSettings settings)
: base(document, settings)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
this._typeNameGenerator = settings.TypeNameGenerator;
}
/// <summary>Initializes a new instance of the <see cref="SwaggerSchemaResolver" /> class.</summary>
/// <param name="document">The Swagger document.</param>
/// <param name="settings">The settings.</param>
/// <exception cref="ArgumentNullException"><paramref name="document" /> is <see langword="null" /></exception>
public SwaggerSchemaResolver(SwaggerDocument document, JsonSchemaGeneratorSettings settings)
: base(document, settings)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
_typeNameGenerator = settings.TypeNameGenerator;
}
public void Given_Default_When_Build_Invoked_Then_It_Should_Throw_Exception()
{
var settings = new JsonSchemaGeneratorSettings();
Action action = () => new SchemaBuilder()
.WithSettings(settings)
.Build(default(Type));
action.Should().Throw <ArgumentNullException>();
}
private static void AddActionScript(StringBuilder script, ModuleApiDescriptionModel module, ControllerApiDescriptionModel controller, ActionApiDescriptionModel action)
{
script.AppendLine($" // action '{action.Name.ToCamelCase()}'");
var settings = new JsonSchemaGeneratorSettings();
settings.FlattenInheritanceHierarchy = true;
settings.DefaultPropertyNameHandling = NJsonSchema.PropertyNameHandling.CamelCase;
settings.DefaultReferenceTypeNullHandling = NJsonSchema.ReferenceTypeNullHandling.NotNull;
var generator = new JsonSchemaGenerator(settings);
script.AppendLine($" abp.schemas.{module.Name.ToCamelCase()}.{controller.Name.ToCamelCase()}.{action.Name.ToCamelCase()} = abp.schemas.{module.Name.ToCamelCase()}.{controller.Name.ToCamelCase()}.{action.Name.ToCamelCase()} || {{}};");
var type = action.ReturnValue.Type;
if (type != typeof(Task))
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task <>))
{
type = type.GetGenericArguments()[0]; // use this...
}
//var schema = await generator.GenerateAsync<JsonSchema4>(typeof(Person));
var schema = generator.GenerateAsync(type).GetAwaiter().GetResult();
var schemaData = schema.ToJson();
//var js = new Newtonsoft.Json.Schema.Generation.JSchemaGenerator();
//var schema = js.Generate(action.ReturnValue.Type);
//schema.Title = action.ReturnValue.Type.Name;
script.Append($" abp.schemas.{module.Name.ToCamelCase()}.{controller.Name.ToCamelCase()}.{action.Name.ToCamelCase()}.returnValue = ");
script.AppendLine(schemaData);
}
foreach (var parameter in action.Parameters)
{
type = parameter.Type;
var schema = generator.GenerateAsync(type).GetAwaiter().GetResult();
var schemaData = schema.ToJson();
script.Append($" abp.schemas.{module.Name.ToCamelCase()}.{controller.Name.ToCamelCase()}.{action.Name.ToCamelCase()}.{parameter.Name.ToCamelCase()} = ");
script.AppendLine(schemaData);
}
//var parameterList = ProxyScriptingJsFuncHelper.GenerateJsFuncParameterList(action, "ajaxParams");
//script.AppendLine($" // action '{action.Name.ToCamelCase()}'");
//script.AppendLine($" abp.schemas.{module.Name.ToCamelCase()}.{controller.Name.ToCamelCase()}{ProxyScriptingJsFuncHelper.WrapWithBracketsOrWithDotPrefix(action.Name.ToCamelCase())} = function({parameterList}) {{");
//script.AppendLine(" return abp.ajax($.extend(true, {");
//AddAjaxCallParameters(script, controller, action);
//script.AppendLine(" }, ajaxParams));;");
//script.AppendLine(" };");
}
private static JObject Generate <T>()
{
JsonSchemaGeneratorSettings settings = new JsonSchemaGeneratorSettings();
settings.SchemaType = SchemaType.OpenApi3;
settings.GenerateKnownTypes = true;
JsonSchema schema = JsonSchema.FromType <T>();
return(JObject.Parse(schema.ToJson()));
}
public static async Task <JsonSchema4> CreateSchema()
{
JsonSchemaGeneratorSettings settings = new JsonSchemaGeneratorSettings()
{
GenerateAbstractProperties = true,
AllowReferencesWithProperties = true
};
var gen = new SimpleSchemaGenerator(settings);
return(await gen.GenerateAsync(typeof(SectionBuilder)));
}
public void Given_Type_When_Build_Invoked_Then_It_Should_Return_Values()
{
var settings = new JsonSchemaGeneratorSettings();
var result = new SchemaBuilder()
.WithSettings(settings)
.Build(typeof(FakeClass));
var schema = JObject.Parse(result.ToJson());
schema["properties"].As <JObject>()
.Should().ContainKey("FakeMessage");
}
public GenerationContext(JsonSchema rootSchema)
{
Schema = rootSchema;
_settings = new JsonSchemaGeneratorSettings();
_settings.SerializerSettings = new JsonSerializerSettings();
_settings.SerializerSettings.Converters.Add(new StringEnumConverter());
_resolver = new JsonSchemaResolver(rootSchema, _settings);
_generator = new JsonSchemaGenerator(_settings);
}
public JsonSchemaProxyScriptGenerator()
{
Logger = NullLogger.Instance;
var settings = new JsonSchemaGeneratorSettings();
settings.FlattenInheritanceHierarchy = true;
settings.DefaultPropertyNameHandling = NJsonSchema.PropertyNameHandling.CamelCase;
settings.DefaultReferenceTypeNullHandling = NJsonSchema.ReferenceTypeNullHandling.NotNull;
settings.AllowReferencesWithProperties = false;
settings.SchemaType = NJsonSchema.SchemaType.JsonSchema;
generator = new JsonSchemaGenerator(settings);
}
static SchemaCache()
{
_settings = new JsonSchemaGeneratorSettings()
{
SchemaType = SchemaType.OpenApi3,
FlattenInheritanceHierarchy = true,
// DefaultEnumHandling = EnumHandling.String,
TypeNameGenerator = new TypeNameGenerator(),
SchemaNameGenerator = new TypeNameGenerator(),
AllowReferencesWithProperties = true,
IgnoreObsoleteProperties = false,
};
}
public void When_FlattenInheritanceHierarchy_is_enabled_then_all_properties_are_in_one_schema()
{
//// Arrange
var settings = new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.String,
FlattenInheritanceHierarchy = true
};
//// Act
var schema = JsonSchema4.FromType(typeof(Teacher), settings);
var data = schema.ToJson();
//// Assert
Assert.IsTrue(schema.Properties.ContainsKey("Name"));
Assert.IsTrue(schema.Properties.ContainsKey("Class"));
}
