/// <exception cref="ArgumentException">The argument 'Input' was empty.</exception> protected async Task <JsonSchema4> GetJsonSchemaAsync() { var input = Input.ToString(); if (string.IsNullOrEmpty(input)) { throw new ArgumentException("The argument 'Input' was empty."); } if (IsJson(input)) { return(await JsonSchema4.FromJsonAsync(input).ConfigureAwait(false)); } if (await DynamicApis.FileExistsAsync(input).ConfigureAwait(false)) { return(await JsonSchema4.FromFileAsync(input).ConfigureAwait(false)); } return(await JsonSchema4.FromUrlAsync(input).ConfigureAwait(false)); }
public static async Task <JsonSchema4> GetProtocolDefinitionSchema(CliArguments args) { JsonSchema4 protocolSchema; if (args.GenerateProtocolSchema || !File.Exists(args.ProtocolSchemaPath)) { Console.WriteLine("Generating protocol definition from current generator interface..."); protocolSchema = await JsonSchema4.FromTypeAsync <ProtocolDefinition>(new JsonSchemaGeneratorSettings() { FlattenInheritanceHierarchy = true }); } else { Console.WriteLine("Using previously obtained protocol schema..."); protocolSchema = await JsonSchema4.FromFileAsync(args.ProtocolSchemaPath); } return(protocolSchema); }
public static void Main(string[] args) { JsonSchema4 schema = JsonSchema4.FromFileAsync("apiDeclaration.json").Result; CSharpGeneratorSettings settings = new CSharpGeneratorSettings { Namespace = "DZzzz.Swag.Specification.Version12", GenerateDataAnnotations = false, GenerateDefaultValues = false, GenerateJsonMethods = false, ArrayBaseType = "System.Collections.Generic.List", ArrayType = "System.Collections.Generic.List", ClassStyle = CSharpClassStyle.Poco, RequiredPropertiesMustBeDefined = false }; CSharpGenerator generator = new CSharpGenerator(schema, settings); var file = generator.GenerateFile(); Console.ReadKey(true); }
private static void WriteCSharp(string name, bool overwrite) { string schemaPath = Path.Combine(outputSchemaDirectory, name + ".schema.json"); JsonSchema4 schema; try { schema = JsonSchema4.FromFileAsync(schemaPath).Result; } catch (Exception exception) { Utils.Print(exception); throw; } string outputCSharp = Path.Combine(outputCSharpDirectory, name + ".cs"); if (!File.Exists(outputCSharp) || overwrite) { Utils.WriteCSharp(schema, new FileInfo(outputCSharp), GetCSharpGeneratorSettings()); } }
public override async Task <JsonSchema4> ResolveFileReferenceAsync(string filePath) { var kettlePrefix = "kettle:"; var kettleIdx = filePath.IndexOf(kettlePrefix); if (kettleIdx != -1) { // Change filepath to properly identify schemas referenced by the kettle IRI. var kettlePath = filePath.Substring(kettleIdx + kettlePrefix.Length); filePath = Path.Combine(_kettleRootSchemaPath, kettlePath + ".json"); } if (_loadedSchemas.ContainsKey(filePath)) { // Wait for parsing to finish! return(await _loadedSchemas[filePath].ConfigureAwait(false)); } var loadTask = JsonSchema4.FromFileAsync(filePath, schema => this); _loadedSchemas[filePath] = loadTask; return(await loadTask.ConfigureAwait(false)); }
static void Process(string schemaPath, string referenceDir, string outPath) { Func <JsonSchema4, JsonReferenceResolver> resolveFactory = s => new CustomKettleRefResolver(new JsonSchemaResolver(s, new JsonSchemaGeneratorSettings()), referenceDir); // Blocks until completely parsed.. var schema = JsonSchema4.FromFileAsync(schemaPath, resolveFactory).Result; // Build the CS file for our main payload var nameResolver = new CustomKettleTypeNameResolver(); var generatorSettings = new CSharpGeneratorSettings() { TypeNameGenerator = nameResolver, ClassStyle = CSharpClassStyle.Poco }; var generator = new CSharpGenerator(schema, generatorSettings); generator.Settings.Namespace = "Kettle.Protocol"; var fileContents = generator.GenerateFile("Payload"); File.WriteAllText(outPath, fileContents); return; }
private static void ProcessFile(string filename, string rootDirectory, string targetDirectory) { var myTI = new CultureInfo("en-US", false).TextInfo; var newFileName = myTI.ToTitleCase(filename.Replace(rootDirectory, targetDirectory).Replace(".json", ".cs")); var newFileDirectory = new System.IO.FileInfo(newFileName).Directory; newFileDirectory.Create(); // If the directory already exists, this method does nothing. if (File.Exists(newFileName)) { File.Delete(newFileName); } var className = Path.GetFileNameWithoutExtension(newFileName); //name the class the same as the file var nameSpace = string.Join(".", "RedoxApi", "Models", myTI.ToTitleCase(newFileDirectory.Name), myTI.ToTitleCase(className)); var schema = JsonSchema4.FromFileAsync(filename).Result; var settings = new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, Namespace = nameSpace }; var generator = new CSharpGenerator(schema, settings); var fileContents = generator.GenerateFile(className); if (!string.IsNullOrEmpty(fileContents)) { File.WriteAllText(newFileName, fileContents); Console.Write("."); } else { Console.WriteLine($"Something went wrong with {filename}"); } }
public async Task Configure() { if (Path.GetExtension(Source) != ".json") { if (!Directory.Exists(AppOutDir)) { throw new DirectoryNotFoundException($"Cannot find app out directory {AppOutDir}"); } String ns; try { var assembly = ProjectAssemblyLoader.LoadProjectAssembly(AppOutDir, out ns); AppNamespace = ns; var type = assembly.GetType(Source); if (type == null) { throw new InvalidOperationException($"Cannot find type {Source} in assembly {assembly.FullName}."); } Schema = await TypeToSchemaGenerator.CreateSchema(type); foreach (var relationship in Schema.GetRelationshipSettings()) { if (relationship.Kind != RelationKind.None) { var otherClrName = relationship.OtherModelClrName; var otherType = assembly.GetType(otherClrName); if (otherType == null) { throw new InvalidOperationException($"Cannot find related type {otherClrName}"); } var otherSchema = await TypeToSchemaGenerator.CreateSchema(otherType); OtherSchemas[otherSchema.Title] = otherSchema; } } } catch (FileLoadException ex) { throw new RunOnFullFrameworkException(ex); } } else { if (!File.Exists(Source)) { throw new MessageException($"Cannot find schema file {Source}."); } Schema = await JsonSchema4.FromFileAsync(Source); } if (Schema.ExtensionData == null) //Make sure this exists { Schema.ExtensionData = new Dictionary <String, Object>(); } ModelName = Schema.Title; PluralModelName = Schema.GetPluralName(); UiController = Schema.GetUiControllerName(); //Make sure directories exist before trying to write files WriteApp = WriteApp && Directory.Exists(AppOutDir); WriteTests = WriteTests && Directory.Exists(TestOutDir); //Validate if (String.IsNullOrWhiteSpace(AppNamespace)) { throw new MessageException($"You must provide an app namespace, one could not be found. Please pass {{--{nameof(AppNamespace)} Your.Namespace}}"); } }
async static Task Main(string inDir, string schemaDir, string outDir, string package) { Directory.CreateDirectory(schemaDir); foreach (var file in Directory.GetFiles(inDir)) { var fileName = Path.GetFileNameWithoutExtension(file); JObject schema = JObject.Parse(File.ReadAllText(file)); var className = Capitalize(fileName); schema["title"] = className; if (schema["items"] != null) { if (schema["items"]["$ref"] == null) { schema["items"]["title"] = Depluralize(className); } else if (schema["items"]["$ref"].Value <string>().StartsWith("#/definitions/")) { var definition = schema["items"]["$ref"].Value <string>().Substring("#/definitions/".Length); schema["definitions"][definition]["title"] = Capitalize(definition); } } ConvertInheritance(schema, "#", (JObject)schema["definitions"], className, inDir); File.WriteAllText(Path.Combine(schemaDir, fileName + ".json"), schema.ToString()); } foreach (var f in Directory.GetFiles(outDir, "*.cs")) { File.Delete(f); } foreach (var file in Directory.GetFiles(schemaDir)) { var schema = await JsonSchema4.FromFileAsync(file); var nameSpace = "Tas." + package + "." + schema.Title; if (schema.Type == JsonObjectType.Array) { if (schema.Item == null) { continue; } else if (schema.Item.Reference == null && schema.Item.Type == JsonObjectType.Object) { schema = schema.Item; } else if (schema.Item.Reference == null || schema.Item.Reference.DocumentPath != null) { //Nonnull DocumentPath indicates direct reference to schema file (e.g "items":{"$ref":"abc.json"}). continue; } else if (schema.Item.Reference.Type == JsonObjectType.Object) { schema = schema.Item.Reference; } else { continue; } } var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings() { Namespace = nameSpace, ClassStyle = CSharpClassStyle.Poco, JsonConverters = new[] { "Newtonsoft.Json.Converters.StringEnumConverter" }, RequiredPropertiesMustBeDefined = false, SchemaType = SchemaType.Swagger2 }); File.WriteAllText(Path.Combine(outDir, schema.Title + ".cs"), generator.GenerateFile()); } }
public static void TestClassinitialize(TestContext context) { mapper = new acmemapper.Mapper(); // load json schema files if (System.IO.Directory.Exists(@"schema")) { foreach (var schema in System.IO.Directory.GetFiles(@"schema", "*.json")) { var fileinfo = new System.IO.FileInfo(schema); schemas.Add(fileinfo.Name.Replace(fileinfo.Extension, String.Empty), JsonSchema4.FromFileAsync(schema).Result); } } }