/// <summary>
/// Processes the "wrap" Json protocol with ChangeResult such as: '{OK: true, change: "Inserted", affected: 3, message: "...", data: {...}}'
/// Throws averment exceptions if OK!=true, no 'data' or 'change' keys are returned
/// </summary>
public static ChangeResult UnwrapChangeResult(this JsonDataMap data)
{
data.NonNull(nameof(data)).ExpectOK();
Aver.IsTrue(data.ContainsKey("change"), "no ['change'] key");
Aver.IsTrue(data.ContainsKey("data"), "no ['data'] key");
return(new ChangeResult(data));
}
/// <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>
/// Returns true if JsonDataMap map is not null and it has a named key and its value matches the specified pattern using * and ? wild cards a la DOS
/// </summary>
public static bool MapValueMatches(this JsonDataMap map, string key, string pattern, bool senseCase = false)
{
if (map == null)
{
return(false);
}
if (key.IsNullOrWhiteSpace())
{
return(false);
}
if (!map.ContainsKey(key))
{
return(false);
}
var got = map[key].AsString(null);
if (got == null && pattern == null)
{
return(true);
}
return(got.MatchPattern(pattern, senseCase: senseCase));
}
/// <summary>
/// Returns true if JsonDataMap map is not null and it has a named key and its value contains the specified substring doing case insensitive
/// comparison by default. Used in unit tests doing partial data matches
/// </summary>
public static bool MapValueContains(this JsonDataMap map, string key, string substring, bool senseCase = false)
{
if (map == null)
{
return(false);
}
if (key.IsNullOrWhiteSpace())
{
return(false);
}
if (!map.ContainsKey(key))
{
return(false);
}
var got = map[key].AsString(null);
if (got == null && substring == null)
{
return(true);
}
return(got.IndexOf(substring, senseCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase) >= 0);
}
/// <summary>
/// Processes the "wrap" Json protocol with JsonDataMap such as: '{OK: true, data: object}'
/// Throws averment exceptions if OK!=true, no 'data' key was returned.
/// The property 'data' may be NULL
/// </summary>
public static object UnwrapPayloadObject(this JsonDataMap data)
{
data.NonNull(nameof(data)).ExpectOK();
Aver.IsTrue(data.ContainsKey("data"), "no ['data'] key");
var result = data["data"];
return(result);
}
/// <summary>
/// Processes the "wrap" Json protocol with JsonDataArray such as: '{OK: true, data: [...array...]}'
/// Throws averment exceptions if OK!=true, no 'data' key was returned or data is not a json array
/// </summary>
public static JsonDataArray UnwrapPayloadArray(this JsonDataMap data)
{
data.NonNull(nameof(data)).ExpectOK();
Aver.IsTrue(data.ContainsKey("data"), "no ['data'] key");
var result = data["data"] as JsonDataArray;
Aver.IsNotNull(result, "['data'] is not array");
return(result);
}
/// <summary>
/// Processes the "wrap" Json protocol such as: '{OK: true, data: {...}}'
/// Throws averment exceptions if OK!=true, no 'data' key was returned or data is not an existing map
/// </summary>
public static JsonDataMap UnwrapPayloadMap(this JsonDataMap data)
{
data.NonNull(nameof(data));
Aver.IsTrue(data["OK"].AsBool(), "OK != true");
Aver.IsTrue(data.ContainsKey("data"), "no ['data'] key");
var result = data["data"] as JsonDataMap;
Aver.IsNotNull(result, "['data'] is not map");
return(result);
}
private JsonDataMap doObject()
{
fetchPrimary(); // skip {
var obj = new JsonDataMap(this.m_CaseSensitiveMaps);
if (token.Type != JsonTokenType.tBraceClose)//empty object {}
{
while (true)
{
if (token.Type != JsonTokenType.tIdentifier && token.Type != JsonTokenType.tStringLiteral)
{
errorAndAbort(JsonMsgCode.eObjectKeyExpected);
}
var key = token.Text;
if (obj.ContainsKey(key))
{
errorAndAbort(JsonMsgCode.eDuplicateObjectKey);
}
fetchPrimary();
if (token.Type != JsonTokenType.tColon)
{
errorAndAbort(JsonMsgCode.eColonOperatorExpected);
}
fetchPrimary();
var value = doAny();
obj[key] = value;
fetchPrimary();
if (token.Type != JsonTokenType.tComma)
{
break;
}
fetchPrimary();
}
if (token.Type != JsonTokenType.tBraceClose)
{
errorAndAbort(JsonMsgCode.eUnterminatedObject);
}
}
return(obj);
}
