protected static async Task WriteProperty <TValue>(JsonTextWriter writer, string propertyName, Dictionary <string, TValue>[] values)
{
await writer.WritePropertyNameAsync(propertyName);
if (values == null)
{
await writer.WriteNullAsync();
return;
}
await writer.WriteStartArrayAsync();
foreach (var dictionary in values)
{
await writer.WriteStartObjectAsync();
foreach (var(name, value) in dictionary)
{
await WriteProperty(writer, name, value);
}
await writer.WriteEndObjectAsync();
}
await writer.WriteEndArrayAsync();
}
public static async Task Main(string[] args)
{
var options = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true)
.AddUserSecrets <Program>()
.AddCommandLine(args)
.Build()
.Get <CalendarOptions>();
var client = new CalendarClient(options.ExchangeUrl, options.Username, options.Password);
var calendars = (await client.ListCalendarsAsync()).OrderBy(c => c.Name).ToList();
using (var writer = new JsonTextWriter(Console.Out))
{
writer.Formatting = Formatting.Indented;
writer.Indentation = 2;
await writer.WriteStartObjectAsync();
foreach (var calendar in calendars)
{
if (!string.IsNullOrWhiteSpace(options.Filter) && !calendar.Name.Contains(options.Filter, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
await writer.WritePropertyNameAsync(Regex.Replace(calendar.Name, "\\W+", "_").Trim('_'));
await writer.WriteStartObjectAsync();
await writer.WritePropertyNameAsync("Name");
await writer.WriteValueAsync(calendar.Name);
await writer.WritePropertyNameAsync("Location");
await writer.WriteNullAsync();
await writer.WritePropertyNameAsync("Source");
if (options.Source != null)
{
await writer.WriteValueAsync(options.Source);
}
else
{
await writer.WriteNullAsync();
}
await writer.WritePropertyNameAsync("ExchangeId");
await writer.WriteValueAsync(calendar.Id);
await writer.WritePropertyNameAsync("ShowInTodayOverview");
await writer.WriteValueAsync(false);
await writer.WriteEndObjectAsync();
}
await writer.WriteEndObjectAsync();
}
Console.ReadLine();
}
public static Func <AppFunc, AppFunc> Create(
Index index,
string identityField,
Func <string, IEnumerable <KeyValuePair <string, string> > > transform)
{
return(next => async env =>
{
var ctx = new OwinContext(env);
if (ctx.Request.Path.HasValue)
{
var id = ctx.Request.Path.Value.Substring(1);
if ("GET".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
var obj = index.GetByTerm(identityField, id);
if (obj == null)
{
await next(env).ConfigureAwait(false);
return;
}
var ct = ctx.Request.CallCancelled;
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
ctx.Response.ContentType = "application/json";
using (var writer = new JsonTextWriter(new StreamWriter(ctx.Response.Body)))
{
await writer.WriteStartObjectAsync(ct).ConfigureAwait(false);
foreach (var p in obj.GroupBy(x => x.Key))
{
await writer.WritePropertyNameAsync(p.Key, ct).ConfigureAwait(false);
var values = p.ToArray();
if (values.Length == 0)
{
await writer.WriteNullAsync(ct).ConfigureAwait(false);
}
else if (values.Length == 1)
{
await writer.WriteValueAsync(values[0].Value, ct).ConfigureAwait(false);
}
else
{
await writer.WriteStartArrayAsync(ct).ConfigureAwait(false);
foreach (var v in values)
{
await writer.WriteValueAsync(v.Value, ct).ConfigureAwait(false);
}
await writer.WriteEndArrayAsync(ct).ConfigureAwait(false);
}
}
await writer.WriteEndObjectAsync(ct).ConfigureAwait(false);
}
}
else if ("PUT".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
var stream = new StreamReader(ctx.Request.Body);
var json = await stream.ReadToEndAsync().ConfigureAwait(false);
index.UpdateByTerm(identityField, id, transform(json));
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
}
else if ("POST".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
if (index.GetByTerm(identityField, id) != null)
{
ctx.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var stream = new StreamReader(ctx.Request.Body);
var json = await stream.ReadToEndAsync().ConfigureAwait(false);
index.LoadDocuments(new[] { transform(json) });
ctx.Response.StatusCode = (int)HttpStatusCode.Created;
}
else if ("DELETE".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
index.DeleteByTerm(identityField, id);
}
else
{
ctx.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
ctx.Response.ContentType = "application/json";
ctx.Response.Headers["Allow"] = "GET,PUT,POST,DELETE";
await ctx.Response.WriteAsync("\"Method Not Allowed\"", ctx.Request.CallCancelled).ConfigureAwait(false);
return;
}
}
else
{
await next(env).ConfigureAwait(false);
}
});
}
public static async Task <string> AddUpdateFieldAsync <T>(string jsonSource, string fieldName, T value)
{
StringBuilder sb = new StringBuilder();
using (var sw = new StringWriter(sb))
using (JsonWriter writer = new JsonTextWriter(sw))
using (var sr = new StringReader(jsonSource))
using (JsonReader reader = new JsonTextReader(sr)) {
writer.Formatting = Formatting.Indented;
bool currentObjectHasTargetField = false;
while (await reader.ReadAsync())
{
if (reader.TokenType == JsonToken.EndObject &&
currentObjectHasTargetField == false)
{
await writer.WritePropertyNameAsync(fieldName);
await writer.WriteValueAsync(value);
await writer.WriteEndObjectAsync();
currentObjectHasTargetField = false; //reinitialize for next object
}
else if (reader.TokenType == JsonToken.PropertyName &&
reader.Value.ToString() == fieldName)
{
await writer.WritePropertyNameAsync(fieldName);
await writer.WriteValueAsync(value);
await reader.ReadAsync(); //read and ignore current value for target field
currentObjectHasTargetField = true; //to not add target field at end of object
}
else
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
await writer.WritePropertyNameAsync(reader.Value.ToString());
break;
case JsonToken.Boolean:
case JsonToken.Bytes:
case JsonToken.Date:
case JsonToken.Float:
case JsonToken.Integer:
case JsonToken.String:
await writer.WriteValueAsync(reader.Value);
break;
case JsonToken.Null:
await writer.WriteNullAsync();
break;
case JsonToken.StartObject:
await writer.WriteStartObjectAsync();
break;
case JsonToken.StartArray:
await writer.WriteStartArrayAsync();
break;
case JsonToken.EndArray:
await writer.WriteEndArrayAsync();
break;
case JsonToken.EndObject:
await writer.WriteEndObjectAsync();
currentObjectHasTargetField = false; //reinitialize
break;
case JsonToken.Comment:
await writer.WriteCommentAsync(reader.Value.ToString());
break;
}
}
}
}
return(sb.ToString());
}
public async Task WriteReadWriteAsync()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (
JsonWriter jsonWriter = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented
}
)
{
await jsonWriter.WriteStartArrayAsync();
await jsonWriter.WriteValueAsync(true);
await jsonWriter.WriteStartObjectAsync();
await jsonWriter.WritePropertyNameAsync("integer");
await jsonWriter.WriteValueAsync(99);
await jsonWriter.WritePropertyNameAsync("string");
await jsonWriter.WriteValueAsync("how now brown cow?");
await jsonWriter.WritePropertyNameAsync("array");
await jsonWriter.WriteStartArrayAsync();
for (int i = 0; i < 5; i++)
{
await jsonWriter.WriteValueAsync(i);
}
await jsonWriter.WriteStartObjectAsync();
await jsonWriter.WritePropertyNameAsync("decimal");
await jsonWriter.WriteValueAsync(990.00990099m);
await jsonWriter.WriteEndObjectAsync();
await jsonWriter.WriteValueAsync(5);
await jsonWriter.WriteEndArrayAsync();
await jsonWriter.WriteEndObjectAsync();
await jsonWriter.WriteValueAsync("This is a string.");
await jsonWriter.WriteNullAsync();
await jsonWriter.WriteNullAsync();
await jsonWriter.WriteEndArrayAsync();
}
string json = sb.ToString();
JsonSerializer serializer = new JsonSerializer();
object jsonObject = serializer.Deserialize(new JsonTextReader(new StringReader(json)));
sb = new StringBuilder();
sw = new StringWriter(sb);
using (
JsonWriter jsonWriter = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented
}
)
{
serializer.Serialize(jsonWriter, jsonObject);
}
Assert.AreEqual(json, sb.ToString());
}
private static async Task ReturnSearchResult(SearchResult result, HttpContext ctx)
{
var ct = ctx.RequestAborted;
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
ctx.Response.ContentType = "application/json";
using (var writer = new JsonTextWriter(new StreamWriter(ctx.Response.Body)))
{
await writer.WriteStartObjectAsync(ct).ConfigureAwait(false);
await writer.WritePropertyNameAsync("totalCount", ct).ConfigureAwait(false);
await writer.WriteValueAsync(result.Total, ct).ConfigureAwait(false);
await writer.WritePropertyNameAsync("elapsed", ct).ConfigureAwait(false);
await writer.WriteValueAsync(result.Elapsed, ct).ConfigureAwait(false);
await writer.WritePropertyNameAsync("results", ct).ConfigureAwait(false);
await writer.WriteStartArrayAsync(ct).ConfigureAwait(false);
foreach (var document in result)
{
if (ct.IsCancellationRequested)
{
return;
}
var obj = document.GroupBy(x => x.Key);
await writer.WriteStartObjectAsync(ct).ConfigureAwait(false);
foreach (var p in obj)
{
await writer.WritePropertyNameAsync(p.Key, ct).ConfigureAwait(false);
var values = p.ToArray();
if (values.Length == 0)
{
await writer.WriteNullAsync(ct).ConfigureAwait(false);
}
else if (values.Length == 1)
{
await writer.WriteValueAsync(values[0].Value, ct).ConfigureAwait(false);
}
else
{
await writer.WriteStartArrayAsync(ct).ConfigureAwait(false);
foreach (var v in values)
{
await writer.WriteValueAsync(v.Value, ct).ConfigureAwait(false);
}
await writer.WriteEndArrayAsync(ct).ConfigureAwait(false);
}
}
await writer.WriteEndObjectAsync(ct).ConfigureAwait(false);
}
await writer.WriteEndArrayAsync(ct).ConfigureAwait(false);
await writer.WriteEndObjectAsync(ct).ConfigureAwait(false);
}
}
public async Task SerializeAsync(Stream responseStream,
IApplication httpApp, IHttpRequest request,
ParameterInfo paramInfo, object obj)
{
var jsonCastersHttpApp = httpApp
.GetType()
.GetAttributesInterface <ICastJson>()
.ToArray();
var encoding = request.TryGetAcceptCharset(out Encoding writerEncoding) ?
writerEncoding
:
new UTF8Encoding(false);
using (var textWriter = new StreamWriter(responseStream, encoding))
{
var jsonWriter = new JsonTextWriter(textWriter);
var serializer = new JsonSerializer();
var converter = new Serialization.ExtrudeConvert(request, httpApp);
serializer.Converters.Add(converter);
await WriteToStreamAsync(jsonWriter, serializer, obj);
}
async Task WriteToStreamAsync(JsonTextWriter jsonWriter, JsonSerializer serializer, object obj)
{
if (obj.IsNull())
{
await jsonWriter.WriteNullAsync();
return;
}
await jsonWriter.WriteStartObjectAsync();
var members = obj.GetType()
.GetPropertyAndFieldsWithAttributesInterface <IProvideApiValue>();
foreach (var(member, apiValueProvider) in members)
{
var memberValue = member.GetPropertyOrFieldValue(obj);
if (memberValue.IsNull() && IgnoreNull)
{
continue;
}
await WriteAsync(member.GetAttributesInterface <ICastJson>(),
onCouldNotCast : () =>
{
var objType = obj.GetType();
return(WriteAsync(objType.GetAttributesInterface <ICastJson>(),
() => WriteAsync(jsonCastersHttpApp,
() =>
{
var memberType = member.GetPropertyOrFieldType();
return WriteAsync(memberType.GetAttributesInterface <ICastJson>(),
async() =>
{
if (memberType.IsArray)
{
await jsonWriter.WritePropertyNameAsync(apiValueProvider.PropertyName);
await WriteArrayAsync(memberType);
return;
}
if (memberType.TryGetAttributeInterface(out IProvideSerialization serializationProvider))
{
await jsonWriter.WritePropertyNameAsync(apiValueProvider.PropertyName);
using (var cacheStream = new MemoryStream())
{
await serializationProvider.SerializeAsync(cacheStream,
httpApp, request, paramInfo, memberValue);
var rawJson = cacheStream.ToArray().GetString(encoding);
await jsonWriter.WriteRawValueAsync(rawJson);
}
return;
}
await jsonWriter.WriteCommentAsync(
$"Cannot find {nameof(ICastJson)} interface for " +
$"{member.DeclaringType.FullName}..{member.Name}");
return;
});
})));
