public async Task <object> PostReadRequest(ReadRequest request)
{
var resultData = await ApplyFilterAsync(request).ConfigureAwait(false);
var opts = new JsonWritingOptions
{
RowsetMetadata = true,
RowsAsMap = false,
Purpose = JsonSerializationPurpose.Marshalling,
MapSkipNulls = false
};
if (request.RequestHeaders != null)
{
opts.RowsetMetadata = !request.RequestHeaders[StandardHeaders.NO_SCHEMA].AsBool(false);
opts.RowsAsMap = request.RequestHeaders[StandardHeaders.ROWS_AS_MAP].AsBool(false);
if (request.RequestHeaders[StandardHeaders.PRETTY].AsBool(false))
{
opts.SpaceSymbols = true;
opts.IndentWidth = 2;
opts.ObjectLineBreak = true;
opts.MemberLineBreak = true;
}
}
return(new JsonResult(resultData, opts));
}
/// <summary>
/// Returns this object converted to JsonDataMap. Only shallow conversion is done, that is:
/// any complex values are added as-is.
/// This method is the backbone of DOC to JSON serialization
/// </summary>
public virtual JsonDataMap ToJsonDataMap(JsonWritingOptions options = null)
{
var map = new JsonDataMap();
foreach (var fd in Schema)
{
string name;
var val = FilterJsonSerializerField(fd, options, out name);
if (name.IsNullOrWhiteSpace())
{
continue; //field was excluded for Json serialization
}
AddJsonSerializerField(fd, options, map, name, val);
}
if (this is IAmorphousData amorph)
{
if (amorph.AmorphousDataEnabled)
{
foreach (var kv in amorph.AmorphousData)
{
var key = kv.Key;
while (map.ContainsKey(key))
{
key += "_";
}
AddJsonSerializerField(null, options, map, key, kv.Value);
}
}
}
return(map);
}
/// <summary>
/// Writes schema as JSON. Do not call this method directly, instead call rowset.ToJSON() or use JSONWriter class
/// </summary>
public void WriteAsJson(System.IO.TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
IEnumerable <FieldDef> defs = m_FieldDefs;
if (options != null && options.RowMapTargetName.IsNotNullOrWhiteSpace())
{
var newdefs = new List <FieldDef>();
foreach (var def in defs)
{
FieldAttribute attr;
var name = def.GetBackendNameForTarget(options.RowMapTargetName, out attr);
if (attr != null)
{
if (attr.StoreFlag == StoreFlag.None || attr.StoreFlag == StoreFlag.OnlyLoad)
{
continue;
}
}
newdefs.Add(def);
}
defs = newdefs;
}
var map = new Dictionary <string, object>
{
{ "Name", "JSON" + m_Name.GetHashCode() },
{ "FieldDefs", defs }
};
JsonWriter.WriteMap(wri, map, nestingLevel, options);
}
public void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
var map = new JsonDataMap
{
{ "utc", Utc.ToMillisecondsSinceUnixEpochStart() },
{ "ssn", Session },
{ "app", App },
{ "ain", AppInstance.ToString("N") },
{ "h", Host },
{ "t", Type },
{ "id", ID.ToString("N") },
{ "dir", DirectorName },
{ "cad", CallerAddress },
{ "cag", CallerAgent },
{ "cpr", CallerPort }
};
var items = m_Items;
if (items != null)
{
map["items"] = items;
}
JsonWriter.WriteMap(wri, map, nestingLevel + 1, options);
}
/// <summary>
/// Writes object into console in JSON format wit a header
/// </summary>
public static void See(this object obj, string header, JsonWritingOptions options = null)
{
Console.WriteLine();
Console.Write(header);
Console.WriteLine(obj.ToJson(options ?? JsonWritingOptions.PrettyPrintRowsAsMap));
Console.WriteLine();
}
public void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$timestamp", new { t = EpochSeconds, i = Increment })
);
}
public override void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$maxKey", 1)
);
}
public override void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$numberLong", Value)
);
}
public void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
var data = new Dictionary <string, object>();
WriteJSONFields(data, options);
JsonWriter.WriteMap(wri, data, nestingLevel, options);
}
/// <summary>
/// Posts body into remote endpoint returning a JsonDataMap result on success.
/// A body is a string, a binary blob or object converted to json using JsonWritingOptions
/// </summary>
public static async Task <JsonDataMap> PostAndGetJsonMapAsync(this HttpClient client,
string uri,
object body,
string contentType = null,
JsonWritingOptions options = null,
bool fetchErrorContent = true,
IEnumerable <KeyValuePair <string, string> > requestHeaders = null)
=> await CallAndGetJsonMapAsync(client, uri, HttpMethod.Post, body, contentType, options, fetchErrorContent, requestHeaders).ConfigureAwait(false);
protected override void AddJsonSerializerField(Schema.FieldDef def, JsonWritingOptions options, Dictionary <string, object> jsonMap, string name, object value)
{
if (def.Name == nameof(Name))
{
jsonMap[PolyHandler.TYPE_MONIKER] = GetType().Name;//add custom type moniker that would allow for polymorphism on deser
}
base.AddJsonSerializerField(def, options, jsonMap, name, value);
}
public void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$oid", Convert.ToBase64String(Bytes))
);
}
protected override void AddJsonSerializerField(Schema.FieldDef def, JsonWritingOptions options, Dictionary <string, object> jsonMap, string name, object value)
{
if (name == nameof(Name))
{
jsonMap["_type"] = GetType().Name;
}
base.AddJsonSerializerField(def, options, jsonMap, name, value);
}
void IJsonWritable.WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options)
{
wri.Write("{\"c\": ");
JsonWriter.EncodeString(wri, Collection, options);
wri.Write(",");
wri.Write("\"id\": ");
((IJsonWritable)Id).WriteAsJson(wri, nestingLevel, options);
wri.Write("}");
}
protected override void AddJsonSerializerField(Schema.FieldDef def, JsonWritingOptions options, Dictionary <string, object> jsonMap, string name, object value)
{
if (def?.Order == 0)
{
BixJsonHandler.EmitJsonBixDiscriminator(this, jsonMap);
}
base.AddJsonSerializerField(def, options, jsonMap, name, value);
}
public void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$regex", Pattern),
new DictionaryEntry("$options", Options.ToBSONString())
);
}
public void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$type", Type),
new DictionaryEntry("$binary", Convert.ToBase64String(Data))
);
}
/// <summary>
/// Writes an object as JSON. Does nothing if object is null
/// </summary>
public void WriteJSON(object data, JsonWritingOptions options = null)
{
if (data == null)
{
return;
}
setWasWrittenTo();
m_NetResponse.ContentType = Azos.Web.ContentType.JSON + ";charset=" + Encoding.WebName;
JsonWriter.Write(data, new NonClosingStreamWrap(getStream()), options, Encoding);
}
void IJsonWritable.WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options)
{
wri.Write('"');
itoa(wri, Era);
wri.Write(':');
itoa(wri, (ulong)Authority);
wri.Write(':');
itoa(wri, Counter);
wri.Write('"');
}
/// <summary>
/// Writes this ChangeResult as a typical JSON object like: {OK: true, change: Inserted ... }
/// </summary>
void IJsonWritable.WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options)
{
JsonWriter.WriteMap(wri, nestingLevel, options,
new DictionaryEntry("OK", true),
new DictionaryEntry("change", Change),
new DictionaryEntry("affected", AffectedCount),
new DictionaryEntry("message", Message),
new DictionaryEntry("data", Data)
);
}
void IJsonWritable.WriteAsJson(System.IO.TextWriter wri, int nestingLevel, JsonWritingOptions options)
{
wri.Write('"');
wri.Write(Era);
wri.Write(':');
wri.Write(Authority);
wri.Write(':');
wri.Write(Counter);
wri.Write('"');
}
/// <summary>
/// Saves configuration into a JSON file
/// </summary>
public void SaveAs(string filename, JsonWritingOptions options = null, Encoding encoding = null)
{
var data = ToConfigurationJSONDataMap();
if (options == null)
{
options = JsonWritingOptions.PrettyPrint;
}
JsonWriter.WriteToFile(data, filename, options, encoding);
base.SaveAs(filename);
}
/// <summary>
/// Writes doc as JSON either as an array or map depending on JSONWritingOptions.RowsAsMap setting.
/// Do not call this method directly, instead call rowset.ToJSON() or use JSONWriter class.
/// Override to perform custom JSOn serialization
/// </summary>
public virtual void WriteAsJson(System.IO.TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
if (options == null || !options.RowsAsMap)
{
JsonWriter.WriteArray(wri, this, nestingLevel, options);
return;
}
var map = ToJsonDataMap(options);
JsonWriter.WriteMap(wri, map, nestingLevel, options);//perform actual Json writing
}
protected override void DoConfigure(IConfigSectionNode node)
{
base.DoConfigure(node);
if (node == null)
{
return;
}
var on = node[CONFIG_JSON_OPT_SECTION];
if (on.Exists)
{
m_Options = FactoryUtils.MakeAndConfigure <JsonWritingOptions>(on, typeof(JsonWritingOptions));
}
}
protected virtual void WriteJSONFields(IDictionary <string, object> data, JsonWritingOptions options)
{
data["cnt"] = this.Count;
data["sd"] = this.UTCTime;
data["ed"] = this.UTCEndTime;
data["rate"] = this.Rate;
data["val"] = this.ValueAsObject;
data["plt"] = this.PlotValue;
if (options != null && options.Purpose >= JsonSerializationPurpose.Marshalling)
{
data["src"] = this.Source;
data["aggr"] = this.IsAggregated;
data["tp"] = this.GetType().FullName;
data["descr"] = this.Description;
data["unit"] = this.ValueUnitName;
}
}
public JsonResult(Exception error, JsonWritingOptions options)
{
var http = WebConsts.STATUS_500;
var descr = WebConsts.STATUS_500_DESCRIPTION;
if (error != null)
{
descr = error.Message;
var httpError = error as HTTPStatusException;
if (httpError != null)
{
http = httpError.StatusCode;
descr = httpError.StatusDescription;
}
}
Data = new { OK = false, http, descr };
Options = options;
}
public override void WriteAsJson(TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
if (Value.ToUniversalTime() >= DateUtils.UNIX_EPOCH_START_DATE)
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$date", Value.ToMillisecondsSinceUnixEpochStart())
);
}
else
{
JsonWriter.WriteMap(wri,
nestingLevel + 1,
options,
new DictionaryEntry("$date", "{{ \"$numberLong\" : {0} }}".Args(Value.Ticks / TimeSpan.TicksPerMillisecond))
);
}
}
/// <summary>
/// Writes row as JSON either as an array or map depending on JSONWritingOptions.RowsAsMap setting.
/// Do not call this method directly, instead call rowset.ToJSON() or use JSONWriter class
/// </summary>
public void WriteAsJson(System.IO.TextWriter wri, int nestingLevel, JsonWritingOptions options = null)
{
if (options == null || !options.RowsAsMap)
{
JsonWriter.WriteArray(wri, this, nestingLevel, options);
return;
}
var map = new Dictionary <string, object>();
foreach (var fd in Schema)
{
string name;
var val = FilterJSONSerializerField(fd, options, out name);
if (name.IsNullOrWhiteSpace())
{
continue;
}
map[name] = val;
}
if (this is IAmorphousData)
{
var amorph = (IAmorphousData)this;
if (amorph.AmorphousDataEnabled)
{
foreach (var kv in amorph.AmorphousData)
{
var key = kv.Key;
while (map.ContainsKey(key))
{
key += "_";
}
map.Add(key, kv.Value);
}
}
}
JsonWriter.WriteMap(wri, map, nestingLevel, options);
}
public void NLSMap_SerializeOnlyOneNoneExisting()
{
var content = "{eng: {n: 'Cucumber',d: 'It is green'}, deu: {n: 'Gurke', d: 'Es ist grün'}}";
var nls = new NLSMap(content);
var options = new JsonWritingOptions {
NLSMapLanguageISO = CoreConsts.ISOA_LANG_RUSSIAN, Purpose = JsonSerializationPurpose.UIFeed
};
var json = nls.ToJson(options);
json.See();
dynamic read = json.JsonToDynamic();
Aver.IsNotNull(read);
Aver.AreEqual("Cucumber", read.n);
Aver.AreEqual("It is green", read.d);
}
public void NLSMap_SerializeOnlyOneExisting()
{
var content = "{eng: {n: 'Cucumber',d: 'It is green'}, deu: {n: 'Gurke', d: 'Es ist grün'}}";
var nls = new NLSMap(content);
var options = new JsonWritingOptions {
NLSMapLanguageISO = "deu", Purpose = JsonSerializationPurpose.UIFeed
};
var json = nls.ToJson(options);
Console.WriteLine(json);
dynamic read = json.JsonToDynamic();
Aver.IsNotNull(read);
Aver.AreEqual("Gurke", read.n);
Aver.AreEqual("Es ist grün", read.d);
}
