/// <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);
}
}
}