public async Task InvokeAsync(HttpContext context)
#endif
{
if (context.Request.Method.Equals(HttpMethods.Get,
StringComparison.Ordinal) && context.IsValidPath(_path))
{
context.Response.ContentType = "application/graphql";
context.Response.Headers.Add(
"Content-Disposition",
new[] { "attachment; filename=\"schema.graphql\"" });
using (var streamWriter = new StreamWriter(
context.Response.Body))
{
SchemaSerializer.Serialize(
_queryExecutor.Schema,
streamWriter);
await streamWriter.FlushAsync();
}
}
else
{
await Next.Invoke(context);
}
}
public Dictionary <string, object> GetMeta()
{
var schema = SchemaGenerator.GenerateFromType <Note>();
using var ms = new MemoryStream();
var writer = new Utf8JsonWriter(ms);
var serializerOptions = new JsonSerializerOptions()
{
WriteIndented = true,
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
DictionaryKeyPolicy = JsonNamingPolicy.CamelCase
};
SchemaSerializer.Serialize(schema, writer, serializerOptions);
writer.Flush();
ms.Position = 0;
using var sr = new StreamReader(ms);
var serializedSchema = sr.ReadToEnd();
return(new Dictionary <string, object>
{
["schema"] = serializedSchema
});
}
public void AddSchema_2()
{
// arrange
Schema customerSchema = Schema.Create(
CustomerSchemaFactory.ConfigureSchema);
Schema contractSchema = Schema.Create(
ContractSchemaFactory.ConfigureSchema);
var builder = new MockStitchingBuilder();
// act
builder.AddSchema("customer", customerSchema)
.AddSchema("contract", contractSchema);
// assert
var services = new EmptyServiceProvider();
var merger = new SchemaMerger();
foreach (KeyValuePair <NameString, ExecutorFactory> item in
builder.Executors)
{
ISchema schema = item.Value.Invoke(services).Schema;
merger.AddSchema(item.Key,
SchemaSerializer.SerializeSchema(schema));
}
SchemaSyntaxSerializer.Serialize(merger.Merge()).MatchSnapshot();
}
static SerializerFactory()
{
_autoSerializer = new AutoSerializer();
_booleanSerializer = new BooleanSerializer();
_enumNameSerializer = new EnumNameSerializer();
_enumValueSerializer = new EnumValueSerializer();
_jsonSerializableSerializer = new JsonSerializableSerializer();
_numericSerializer = new NumericSerializer();
_registeredObjectSerializer = new RegisteredObjectSerializer();
_stringSerializer = new StringSerializer();
_schemaSerializer = new SchemaSerializer();
_uriSerializer = new UriSerializer();
_library = new Dictionary <Type, ISerializer>
{
{ typeof(sbyte), _numericSerializer },
{ typeof(byte), _numericSerializer },
{ typeof(char), _numericSerializer },
{ typeof(short), _numericSerializer },
{ typeof(ushort), _numericSerializer },
{ typeof(int), _numericSerializer },
{ typeof(uint), _numericSerializer },
{ typeof(long), _numericSerializer },
{ typeof(ulong), _numericSerializer },
{ typeof(float), _numericSerializer },
{ typeof(double), _numericSerializer },
{ typeof(decimal), _numericSerializer },
{ typeof(bool), _booleanSerializer },
{ typeof(string), _stringSerializer },
{ typeof(Uri), _uriSerializer }
};
}
public async Task InvokeAsync(HttpContext context)
#endif
{
if (context.Request.Method.Equals(
HttpMethods.Get,
StringComparison.Ordinal) &&
context.IsValidPath(_path))
{
context.Response.ContentType = ContentType.GraphQL;
context.Response.Headers.Add(
"Content-Disposition",
new[] { "attachment; filename=\"schema.graphql\"" });
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream))
{
SchemaSerializer.Serialize(
_queryExecutor.Schema,
streamWriter);
await streamWriter.FlushAsync().ConfigureAwait(false);
memoryStream.Seek(0, SeekOrigin.Begin);
await memoryStream.CopyToAsync(context.Response.Body).ConfigureAwait(false);
}
}
}
else
{
await Next.Invoke(context).ConfigureAwait(false);
}
}
public Task ExecuteAsync(
ControllerActionDescriptor action,
Utf8JsonWriter writer,
JsonSerializerOptions options)
{
var namingPolicy = options.PropertyNamingPolicy;
writer.WriteStartObject();
writer.WriteString(namingPolicy.ConvertName("type"), "object");
writer.WriteStartObject(namingPolicy.ConvertName("properties"));
writer.WriteStartObject(namingPolicy.ConvertName("api"));
writer.WriteString(namingPolicy.ConvertName("type"), "object");
writer.WriteStartObject(namingPolicy.ConvertName("properties"));
writer.WriteStartObject(namingPolicy.ConvertName("title"));
writer.WriteString(namingPolicy.ConvertName("type"), "string");
writer.WriteEndObject();
writer.WriteEndObject();
writer.WriteEndObject();
writer.WriteStartObject(namingPolicy.ConvertName("resources"));
writer.WriteString(namingPolicy.ConvertName("type"), "object");
writer.WriteBoolean(namingPolicy.ConvertName("additionalProperties"), false);
writer.WriteEndObject();
writer.WriteEndObject();
var returnType = action.MethodInfo.GetCustomAttribute <ReturnsAttribute>()?.ReturnType ?? typeof(object);
var links = Links.ForType(FSharpFunc <Type, InputJsonSchema> .FromConverter(SchemaGenerator.getInputSchema), returnType);
SchemaSerializer.writeLinks(links).Invoke(Tuple.Create(writer, options));
writer.WriteEndObject();
return(Task.CompletedTask);
}
private static void AddSchemasFromExecutors(
IDictionary <NameString, DocumentNode> schemas,
IEnumerable <IRemoteExecutorAccessor> accessors)
{
foreach (IRemoteExecutorAccessor accessor in accessors)
{
schemas[accessor.SchemaName] =
SchemaSerializer.SerializeSchema(
accessor.Executor.Schema);
}
}
static void Main(string[] args)
{
// {"@context":"https://schema.org","@type":"CustomType","Name":"Hello World"}
var inputObj = new CustomType
{
Name = "Hello World"
};
var json = SchemaSerializer.SerializeObject(inputObj);
var outputObj = SchemaSerializer.DeserializeObject <CustomType>(json);
}
public void SchemaSerializerTestStruct1()
{
var Serializer = new SchemaSerializer<TestDataStruct>();
Assert.AreEqual("{\r\n\"data1\" : { \"type\" : \"System.Int32\", \"position\": \"0\", \"size\": \"4\" },\r\n\"data2\" : { \"type\" : \"System.Int64\", \"position\": \"5\", \"size\": \"8\" },\r\n\"data3\" : { \"type\" : \"System.String\", \"position\": \"12\", \"size\": \"50\" },\r\n\"data4\" : { \"type\" : \"System.Byte[]\", \"position\": \"62\", \"size\": \"30\" }\r\n}\r\n", Serializer.Schema);
Assert.AreEqual(96, Serializer.StructSize);
var x1 = Serializer.Serialize(new TestDataStruct() { data1 = 1024, data2 = -1024 });
Assert.AreEqual(96, x1.Length);
Assert.AreEqual("000400000000FCFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", BitConverter.ToString(x1).Replace("-",""));
var x2 = Serializer.Serialize(new TestDataStruct() { data1 = Int32.MaxValue, data2 = -13 });
Assert.AreEqual(96, x2.Length);
Assert.AreEqual("FFFFFF7F00F3FFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", BitConverter.ToString(x2).Replace("-", ""));
}
private void WriteIntrospectionResponse(ControllerActionDescriptor action, Utf8JsonWriter writer, JsonSerializerOptions options)
{
var returnType = action.MethodInfo.GetCustomAttribute <ReturnsAttribute>()?.ReturnType ?? typeof(object);
var links = Links.ForType(FSharpFunc <Type, InputJsonSchema> .FromConverter(SchemaGenerator.getInputSchema), returnType);
writer.WriteStartObject();
writer.WritePropertyName("data");
writer.WriteStartObject();
SchemaSerializer.writeLinks(links).Invoke(Tuple.Create(writer, options));
writer.WriteEndObject();
writer.WriteStartObject("meta");
writer.WriteEndObject();
writer.WriteEndObject();
}
public static void StartStructSer()
{
var structser = new SchemaSerializer<Data>();
var StructSize = structser.StructSize;
Byte[] x1 = null;
var sw = new Stopwatch();
sw.Start();
for (var i=0;i<100000;i++)
x1 = structser.SerializeCached(new Data() { data1 = 12, data2 = -12 }, ClearCache: false);
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
var x2 = structser.Serialize(new Data() { data1 = 1024, data2 = -1024 });
var x3 = structser.Serialize(new Data() { data1 = 80000, data2 = -80000 });
var x4 = structser.Serialize(new Data() { data1 = Int32.MaxValue, data2 = -13 });
var x5 = structser.Serialize(new Data() { data1 = Int32.MinValue, data2 = -13 });
}
static void Main(string[] args)
{
Console.WriteLine(args[0]);
using (FileStream zipToOpen = new FileStream(@args[0], FileMode.Open))
{
var recipes = RecipeKeeperImporter.GetSchemaRecipes(zipToOpen);
string recipesJsonStr = SchemaSerializer.SerializeObject(recipes);
// FIXME: line andings are currently not write correct to file
// correct the line endings for host OS
//recipesJsonStr = Regex.Replace(recipesJsonStr, @"\\r\\n?|\\n", Environment.NewLine);
File.WriteAllText("recipes.json", recipesJsonStr, Encoding.UTF8);
Console.WriteLine(recipesJsonStr);
}
Console.WriteLine("Import completed!");
}
public Task ExecuteAsync(
ControllerActionDescriptor action,
Utf8JsonWriter writer,
JsonSerializerOptions options)
{
var method = action.MethodInfo;
var returnType = method.GetCustomAttribute <ReturnsAttribute>()?.ReturnType;
if (returnType != null)
{
var wrapperType = typeof(MicrotypeContainerWrapper <>).MakeGenericType(returnType);
var schema = SchemaGenerator.GenerateFromType(wrapperType);
SchemaSerializer.Serialize(schema, writer, options);
}
else
{
writer.WriteStartObject();
writer.WriteEndObject();
}
return(Task.CompletedTask);
}
private async Task HandleRequestAsync(HttpContext context)
{
IRequestExecutor requestExecutor = await GetExecutorAsync(context.RequestAborted);
string fileName =
requestExecutor.Schema.Name.IsEmpty ||
requestExecutor.Schema.Name.Equals(Schema.DefaultName)
? "schema.graphql"
: requestExecutor.Schema.Name + ".schema.graphql";
context.Response.ContentType = ContentType.GraphQL;
context.Response.Headers.Add(
"Content-Disposition",
new[] { $"attachment; filename=\"{fileName}\"" });
await SchemaSerializer.SerializeAsync(
requestExecutor.Schema,
context.Response.Body,
indented : true,
context.RequestAborted)
.ConfigureAwait(false);
}
private async Task HandleRequestAsync(HttpContext context)
{
IRequestExecutor requestExecutor = await GetExecutorAsync(context.RequestAborted);
string fileName =
requestExecutor.Schema.Name.IsEmpty ||
requestExecutor.Schema.Name.Equals(Schema.DefaultName)
? "schema.graphql"
: requestExecutor.Schema.Name + ".schema.graphql";
context.Response.ContentType = ContentType.GraphQL;
context.Response.Headers.Add(
"Content-Disposition",
new[] { $"attachment; filename=\"{fileName}\"" });
await using var memoryStream = new MemoryStream();
await using var streamWriter = new StreamWriter(memoryStream);
SchemaSerializer.Serialize(requestExecutor.Schema, streamWriter);
await streamWriter.FlushAsync().ConfigureAwait(false);
memoryStream.Seek(0, SeekOrigin.Begin);
await memoryStream.CopyToAsync(context.Response.Body).ConfigureAwait(false);
}
public void FromDiskTest()
{
var provider = new SchemaSerializer().ReadFromDisk(@"c:\testdata.txt");
Assert.NotNull(provider);
}
private static T DeserializeObject <T>(string json)
where T : IValues
=> SchemaSerializer.DeserializeObject <TestModel <T> >(json).Property;
private static string SerializeObject <T>(T value)
where T : IValues
=> SchemaSerializer.SerializeObject(new TestModel <T> {
Property = value
});
public DocumentNode ToDocument(bool includeSpecScalars = false) => SchemaSerializer.SerializeSchema(this, includeSpecScalars);
public string Print() => SchemaSerializer.Serialize(this);
