public static void WriteJson(this Game.Planet self, JsonTextWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName("id");
writer.WriteValue(self.id);
if (self.rocketUsed == null)
{
writer.WritePropertyName("rocketUsed");
writer.WriteNull();
}
else
{
writer.WritePropertyName("rocketUsed");
self.rocketUsed.WriteJson(writer);
}
if (self.config == null)
{
writer.WritePropertyName("config");
writer.WriteNull();
}
else
{
writer.WritePropertyName("config");
self.config.WriteJson(writer);
}
writer.WritePropertyName("rotationPhase");
writer.WriteValue(self.rotationPhase);
writer.WritePropertyName("hp");
writer.WriteValue(self.hp);
writer.WritePropertyName("position");
self.position.WriteJson(writer);
writer.WritePropertyName("currentRocketCooldown");
writer.WriteValue(self.currentRocketCooldown);
writer.WriteEndObject();
}
public async void EvaluateJavaScript(string js, string cb)
{
var sb = new StringBuilder();
var sw = new StringWriter(sb);
JsonWriter writer;
try {
writer = new JsonTextWriter(sw)
{
Formatting = Formatting.None
};
var mf = _view.CurrentBrowser.GetMainFrame();
var response = await mf.EvaluateScriptAsync(js, TimeSpan.FromMilliseconds(500).ToString());
if (response.Success && response.Result is IJavascriptCallback)
{
response = await((IJavascriptCallback)response.Result).ExecuteAsync("");
}
writer.WriteStartObject();
writer.WritePropertyName("success");
writer.WriteValue(response.Success);
writer.WritePropertyName("message");
writer.WriteValue(response.Message);
writer.WritePropertyName("error");
writer.WriteNull();
writer.WritePropertyName("callbackName");
writer.WriteValue(cb);
writer.WritePropertyName("result");
if (response.Success && response.Result != null)
{
writer.WriteRawValue(JsonConvert.SerializeObject(response.Result, Formatting.None));
}
else
{
writer.WriteNull();
}
writer.WriteEndObject();
}
catch (Exception e) {
Console.WriteLine(@"EvaluateJavaScript JS error: " + e.Message);
writer = new JsonTextWriter(sw)
{
Formatting = Formatting.None
};
writer.WriteStartObject();
writer.WritePropertyName("message");
writer.WriteNull();
writer.WritePropertyName("error");
writer.WriteValue(e.Message);
writer.WritePropertyName("result");
writer.WriteNull();
writer.WritePropertyName("success");
writer.WriteValue(false);
writer.WritePropertyName("guid");
writer.WriteValue(cb);
writer.WriteEndObject();
}
Context.DispatchEvent(CefView.AsCallbackEvent, sb.ToString());
}
public void ToJSON(JsonTextWriter jwriter)
{
jwriter.WriteStartArray();
foreach (DictionaryEntry item in this.Dictionary)
{
jwriter.WriteStartObject();
jwriter.WriteMember("key");
jwriter.WriteString(item.Key.ToString());
//write the qualified type name of the value
//write the value
if (item.Value == null)
{
jwriter.WriteMember("type");
jwriter.WriteNull();
jwriter.WriteMember("value");
jwriter.WriteNull();
}
else
{
TypeConverter typeConverter = TypeDescriptor.GetConverter(item.Value.GetType());
jwriter.WriteMember("type");
jwriter.WriteString(item.Value.GetType().AssemblyQualifiedName);
jwriter.WriteMember("value");
jwriter.WriteString(typeConverter.ConvertToString(item.Value));
}
jwriter.WriteEndObject();
}
jwriter.WriteEndArray();
}
public void WriteReadWrite()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonTextWriter(sw))
{
jsonWriter.WriteStartArray();
jsonWriter.WriteValue(true);
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("integer");
jsonWriter.WriteValue(99);
jsonWriter.WritePropertyName("string");
jsonWriter.WriteValue("how now brown cow?");
jsonWriter.WritePropertyName("array");
jsonWriter.WriteStartArray();
for (int i = 0; i < 5; i++)
{
jsonWriter.WriteValue(i);
}
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("decimal");
jsonWriter.WriteValue(990.00990099m);
jsonWriter.WriteEndObject();
jsonWriter.WriteValue(5);
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
jsonWriter.WriteValue("This is a string.");
jsonWriter.WriteNull();
jsonWriter.WriteNull();
jsonWriter.WriteEndArray();
}
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))
{
serializer.Serialize(sw, jsonObject);
}
Assert.AreEqual(json, sb.ToString());
}
public void Visit(NodeReference r)
{
if (r.IsNull)
{
writer.WriteNull();
}
else
{
writer.WriteValue(r.Index);
}
}
public void WriteJson(JsonTextWriter generator, WritingOptions writingOptions)
{
generator.WriteStartObject();
generator.WriteField("tribeVersion", TribeVersion);
generator.WritePropertyName("tribe");
if (Tribe != null)
{
Tribe.WriteJson(generator, writingOptions);
}
else
{
generator.WriteNull();
}
if (Objects.Count > (Tribe == null ? 0 : 1))
{
generator.WriteArrayFieldStart("objects");
foreach (GameObject gameObject in Objects.Where(o => o != Tribe))
{
gameObject.WriteJson(generator, writingOptions);
}
generator.WriteEndArray();
}
generator.WriteEndObject();
}
private void WriteJsonMessage(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IEnumerable <KeyValuePair <string, object> > state)
{
using (var sw = new StringWriter())
using (var jtw = new JsonTextWriter(sw))
{
jtw.WriteStartObject();
jtw.WritePropertyName("time");
jtw.WriteValue(DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"));
jtw.WritePropertyName("level");
jtw.WriteValue(GetLogLevelString(logLevel));
jtw.WritePropertyName("cat");
jtw.WriteValue(logName);
jtw.WritePropertyName("eventID");
jtw.WriteValue(eventId);
if (_isIncludeScope)
{
jtw.WritePropertyName("scope");
jtw.WriteValue(GetScopeInformation());
}
if (string.IsNullOrEmpty(message) == false)
{
jtw.WritePropertyName("msg");
jtw.WriteValue(message);
}
if (exception != null)
{
jtw.WritePropertyName("ex");
jtw.WriteValue(exception.ToString());
}
if (state != null)
{
foreach (var item in state)
{
if (item.Key == "{OriginalFormat}")
{
continue;
}
jtw.WritePropertyName(item.Key);
if (item.Value != null)
{
try
{
jtw.WriteValue(item.Value);
}
catch (Exception)
{
jtw.WriteValue(item.Value.ToString());
}
}
else
{
jtw.WriteNull();
}
}
}
jtw.WriteEndObject();
sw.WriteLine();
_messageQueue.EnqueueMessage(sw.ToString());
}
}
public override string ToString()
{
Dictionary <String, byte[]> binaries = new Dictionary <String, byte[]>();
// create textual data
using (MemoryStream stream = new MemoryStream())
{
using (TextWriter text = new StreamWriter(stream))
{
using (JsonWriter generator = new JsonTextWriter(text))
{
generator.WriteStartObject();
foreach (KeyValuePair <String, IValue> entry in values)
{
generator.WritePropertyName(entry.Key);
if (entry.Value == null)
{
generator.WriteNull();
}
else
{
Object id = System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(this);
entry.Value.ToJson(null, generator, id, entry.Key, false, binaries);
}
}
generator.WriteEndObject();
}
}
return(System.Text.Encoding.UTF8.GetString(stream.ToArray()));
}
}
public ResponseBody(int returnCode, string errorMessage, string response, SimpleRESTfulReturn type)
{
StringBuilder responseBuilder = new StringBuilder();
using (JsonWriter writer = new JsonTextWriter(new StringWriter(responseBuilder)))
{
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("ReturnCode");
writer.WriteValue(returnCode);
writer.WritePropertyName("ErrorMessage");
writer.WriteValue(errorMessage);
writer.WritePropertyName("Response");
if (type == SimpleRESTfulReturn.Empty)
{
writer.WriteNull();
}
else if (type == SimpleRESTfulReturn.Json)
{
writer.WriteRawValue(response);
}
else if (type == SimpleRESTfulReturn.PlainText)
{
writer.WriteValue(response);
}
else
{
writer.WriteValue(response);
}
writer.WriteEndObject();
writer.Flush();
}
Value = responseBuilder.ToString();
}
private void WriteEmptyKeys(CultureInfo sourceCulture, string fullFilePath, string key)
{
var values = key.Split('.').Take(2).ToList();
var(ns, loc) = Tuple.Create(values[0], values[1]);
var sourceFilePath = $"{_options.Value.ResourcesPath}/{ns}.{sourceCulture.Name}.json";
using (var str = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var outStream = File.Create(fullFilePath))
using (var sWriter = new StreamWriter(outStream))
using (var writer = new JsonTextWriter(sWriter))
using (var sReader = new StreamReader(str))
using (var reader = new JsonTextReader(sReader))
{
writer.Formatting = Formatting.Indented;
var jobj = JObject.Load(reader);
writer.WriteStartObject();
foreach (var property in jobj.Properties())
{
writer.WritePropertyName(property.Name);
writer.WriteNull();
}
writer.WriteEndObject();
}
}
public static void WriteJson(this Game.RocketInstance self, JsonTextWriter writer)
{
writer.WriteStartObject();
if (self.config == null)
{
writer.WritePropertyName("config");
writer.WriteNull();
}
else
{
writer.WritePropertyName("config");
self.config.WriteJson(writer);
}
writer.WritePropertyName("position");
self.position.WriteJson(writer);
writer.WritePropertyName("speed");
self.speed.WriteJson(writer);
writer.WritePropertyName("invulTime");
writer.WriteValue(self.invulTime);
writer.WritePropertyName("lifeTime");
writer.WriteValue(self.lifeTime);
writer.WritePropertyName("parentId");
writer.WriteValue(self.parentId);
writer.WriteEndObject();
}
public void ValueFormatting()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonTextWriter(sw))
{
jsonWriter.WriteStartArray();
jsonWriter.WriteValue('@');
jsonWriter.WriteValue("\r\n\t\f\b?{\\r\\n\"\'");
jsonWriter.WriteValue(true);
jsonWriter.WriteValue(10);
jsonWriter.WriteValue(10.99);
jsonWriter.WriteValue(0.99);
jsonWriter.WriteValue(0.000000000000000001d);
jsonWriter.WriteValue(0.000000000000000001m);
jsonWriter.WriteValue((string)null);
jsonWriter.WriteValue((object)null);
jsonWriter.WriteValue("This is a string.");
jsonWriter.WriteNull();
jsonWriter.WriteUndefined();
jsonWriter.WriteEndArray();
}
string expected = @"[""@"",""\r\n\t\f\b?{\\r\\n\""'"",true,10,10.99,0.99,1E-18,0.000000000000000001,null,null,""This is a string."",null,undefined]";
string result = sb.ToString();
Console.WriteLine("ValueFormatting");
Console.WriteLine(result);
Assert.AreEqual(expected, result);
}
public static void JayrockWriterObjects()
{
for (int j = 0; j < Common.Iterations; j++)
{
StringBuilder output = new StringBuilder();
JsonWriter writer = new JsonTextWriter(new StringWriter(output));
int n = Common.SampleObject.Length;
for (int i = 0; i < n; i += 2)
{
switch ((char)Common.SampleObject[i])
{
case '{':
writer.WriteStartObject();
break;
case '}':
writer.WriteEndObject();
break;
case '[':
writer.WriteStartArray();
break;
case ']':
writer.WriteEndArray();
break;
case 'P':
writer.WriteMember(
(string)Common.SampleObject[i + 1]);
break;
case 'I':
writer.WriteNumber(
(int)Common.SampleObject[i + 1]);
break;
case 'D':
writer.WriteNumber(
(double)Common.SampleObject[i + 1]);
break;
case 'S':
writer.WriteString(
(string)Common.SampleObject[i + 1]);
break;
case 'B':
writer.WriteBoolean(
(bool)Common.SampleObject[i + 1]);
break;
case 'N':
writer.WriteNull();
break;
}
}
}
}
public void WriteValue(IValue Value, bool UseFormatWithExponent = false)
{
if (!IsOpen())
{
NotOpenException();
}
switch (Value.DataType)
{
case DataType.String:
WriteStringValue(Value.AsString());
break;
case DataType.Number:
decimal d = Value.AsNumber();
if (d == Math.Round(d))
{
Int64 i = Convert.ToInt64(d);
if (UseFormatWithExponent)
{
_writer.WriteRawValue(string.Format(Thread.CurrentThread.CurrentCulture, "{0:E}", i));
}
else
{
_writer.WriteValue(i);
}
}
else
{
if (UseFormatWithExponent)
{
_writer.WriteRawValue(string.Format(string.Format(Thread.CurrentThread.CurrentCulture, "{0:E}", d)));
}
else
{
_writer.WriteValue(d);
}
}
break;
case DataType.Date:
_writer.WriteValue(Value.AsDate());
break;
case DataType.Boolean:
_writer.WriteValue(Value.AsBoolean());
break;
case DataType.Undefined:
_writer.WriteNull();
break;
default:
throw new RuntimeException("Тип переданного значения не поддерживается.");
}
}
public static void JsonTextWriterDemo()
{
Console.Clear();
Console.WriteLine("*** JsonTextWriter Demo ***");
// The JsonTextWriter is the opposite of the JsonTextReader method. It is one way only,
// so it only writes, does not use reflections (so is higly performant) and it's not cacheable.
// Like the JsonTextReader method, it is itended to be used with very large json documents that
// need to squeeze every bit of performance
// While the JsonTextReader takes a json document and produces a series of json tokens and values,
// the JsonTextWriter takes a series of tokens and values and produces a json document.
// In C# strings are immutable, so we need to use a StringWriter, which produces a StringBuilder
// to build our string, else we might pay a pretty big performance penalty
var sw = new StringWriter();
var writer = new JsonTextWriter(sw);
// Before we start writing our json document, we need to configure any serialization formatters
// we might want, because writing is done instantly.
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("name");
writer.WriteValue("Alex Griciuc");
writer.WritePropertyName("favorites");
writer.WriteStartArray();
writer.WriteValue(".NET Core");
writer.WriteValue("JSON.Net");
writer.WriteEndArray();
writer.WritePropertyName("dateOfBirth");
writer.WriteValue(new DateTime(1983, 11, 13));
writer.WritePropertyName("happy");
writer.WriteValue(true);
writer.WritePropertyName("issues");
writer.WriteNull();
// Attention! Nested objects must start with a property name, else JSON.Net
// will throw an exception
writer.WritePropertyName("car");
writer.WriteStartObject();
writer.WritePropertyName("model");
writer.WriteValue("Renault Symbol 16v");
writer.WritePropertyName("year");
writer.WriteValue(2008);
// Close the nested object }
writer.WriteEndObject();
// Close the parent object }
writer.WriteEndObject();
// After we are done writing the json document we need to Flush the writer stream.
writer.Flush();
// Finally to be able to output the string we need to get the StringBuilder from
// the StringWriter object
string jsonText = sw.GetStringBuilder().ToString();
Console.WriteLine(jsonText);
Console.ReadLine();
}
public void EmitExpression(SyntaxBase syntax)
{
switch (syntax)
{
case BooleanLiteralSyntax boolSyntax:
writer.WriteValue(boolSyntax.Value);
break;
case IntegerLiteralSyntax integerSyntax:
writer.WriteValue(integerSyntax.Value);
break;
case NullLiteralSyntax _:
writer.WriteNull();
break;
case ObjectSyntax objectSyntax:
writer.WriteStartObject();
EmitObjectProperties(objectSyntax);
writer.WriteEndObject();
break;
case ArraySyntax arraySyntax:
writer.WriteStartArray();
foreach (ArrayItemSyntax itemSyntax in arraySyntax.Items)
{
EmitExpression(itemSyntax.Value);
}
writer.WriteEndArray();
break;
case ParenthesizedExpressionSyntax _:
case UnaryOperationSyntax _:
case BinaryOperationSyntax _:
case TernaryOperationSyntax _:
case StringSyntax _:
case InstanceFunctionCallSyntax _:
case FunctionCallSyntax _:
case ArrayAccessSyntax _:
case PropertyAccessSyntax _:
case ResourceAccessSyntax _:
case VariableAccessSyntax _:
EmitLanguageExpression(syntax);
break;
default:
throw new NotImplementedException($"Cannot emit unexpected expression of type {syntax.GetType().Name}");
}
}
public static void ShowJsonTextWriter()
{
Console.Clear();
Console.WriteLine("*** JsonTextWriter Demo ***");
//Final JSON
/*
* {
* "name": "Xavier Morera",
* "courses": [
* "Solr",
* "dotTrace"],
* "since": "2014-01-14T00:00:00",
* "happy": true,
* "issues": null,
* "car": {
* "model": "Land Rover Series III",
* "year": 1976}
* }
*/
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
writer.Formatting = Formatting.Indented; //try at the beginning and at the end
writer.WriteStartObject();
writer.WritePropertyName("name");
writer.WriteValue("Xavier Morera");
writer.WritePropertyName("courses");
writer.WriteStartArray();
writer.WriteValue("Solr");
writer.WriteValue("dotTrace");
writer.WriteEndArray();
writer.WritePropertyName("since");
writer.WriteValue(new DateTime(2014, 01, 14));
writer.WritePropertyName("happy");
writer.WriteValue(true);
writer.WritePropertyName("issues");
writer.WriteNull();
writer.WritePropertyName("car"); // what happens if you forget this one? Exception!
writer.WriteStartObject();
writer.WritePropertyName("model");
writer.WriteValue("Land Rover Series III");
writer.WritePropertyName("year");
writer.WriteValue(1976);
writer.WriteEndObject();
writer.WriteEndObject();
writer.Flush();
string jsonText = sw.GetStringBuilder().ToString();
Console.WriteLine(jsonText);
}
private void SerializeValue(object value, JsonTextWriter jsonWriter)
{
if (value != null)
{
string valueJson = JsonConvert.SerializeObject(value, this.serverConfig.Value.JsonSerializerSettings);
jsonWriter.WriteRawValue(valueJson);
}
else
{
jsonWriter.WriteNull();
}
}
public override void WriteJson(JsonTextWriter generator, WritingOptions writingOptions)
{
generator.WriteStartArray();
// Marker
generator.WriteNull();
foreach (ArkByteValue bv in this)
{
generator.WriteValue(bv.NameValue.ToString());
}
generator.WriteEndArray();
}
public void PostMessage(JavascriptMessage param)
{
var sb = new StringBuilder();
var sw = new StringWriter(sb);
var writer = new JsonTextWriter(sw);
writer.WriteStartObject();
writer.WritePropertyName("functionName");
writer.WriteValue(param.functionName);
writer.WritePropertyName("args");
if (param.args != null && param.args.Count > 0)
{
writer.WriteStartArray();
foreach (var value in param.args)
{
writer.WriteValue(value);
}
writer.WriteEndArray();
}
else
{
writer.WriteNull();
}
writer.WritePropertyName("callbackName");
if (!string.IsNullOrEmpty(param.callbackName))
{
writer.WriteValue(param.callbackName);
}
else
{
writer.WriteNull();
}
writer.WriteEndObject();
_context.SendEvent(JsCallbackEvent, sb.ToString());
}
private String serializeRoot()
{
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
writer.WritePropertyName("total");
writer.WriteValue(serializationObjectsRoot.total);
writer.WritePropertyName("result");
writer.WriteStartArray();
foreach (Result result in serializationObjectsRoot.result)
{
writer.WriteStartObject();
writer.WritePropertyName("category");
if (result.category != null)
{
writer.WriteStartArray();
foreach (string category in result.category)
{
writer.WriteValue(category);
}
writer.WriteEndArray();
}
else
{
writer.WriteNull();
}
writer.WritePropertyName("icon_url");
writer.WriteValue(result.icon_url);
writer.WritePropertyName("id");
writer.WriteValue(result.id);
writer.WritePropertyName("url");
writer.WriteValue(result.url);
writer.WritePropertyName("value");
writer.WriteValue(result.value);
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WriteEndObject();
return(sw.ToString());
}
/// <summary>
/// Returns a <see cref="string"/> representation of the current instance that can be used in logs.
/// Note: sensitive parameters like client secrets are automatically removed for security reasons.
/// </summary>
/// <returns>The indented JSON representation corresponding to this message.</returns>
public override string ToString()
{
var builder = new StringBuilder();
using (var writer = new JsonTextWriter(new StringWriter(builder, CultureInfo.InvariantCulture)))
{
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
foreach (var parameter in Parameters)
{
writer.WritePropertyName(parameter.Key);
// Remove sensitive parameters from the generated payload.
switch (parameter.Key)
{
case OpenIdConnectConstants.Parameters.AccessToken:
case OpenIdConnectConstants.Parameters.Assertion:
case OpenIdConnectConstants.Parameters.ClientAssertion:
case OpenIdConnectConstants.Parameters.ClientSecret:
case OpenIdConnectConstants.Parameters.Code:
case OpenIdConnectConstants.Parameters.IdToken:
case OpenIdConnectConstants.Parameters.IdTokenHint:
case OpenIdConnectConstants.Parameters.Password:
case OpenIdConnectConstants.Parameters.RefreshToken:
case OpenIdConnectConstants.Parameters.Token:
{
writer.WriteValue("[removed for security reasons]");
continue;
}
}
var token = (JToken)parameter.Value;
if (token == null)
{
writer.WriteNull();
continue;
}
token.WriteTo(writer);
}
writer.WriteEndObject();
}
return(builder.ToString());
}
public static void WriteToken(BionReader reader, JsonTextWriter writer)
{
switch (reader.TokenType)
{
case BionToken.StartObject:
writer.WriteStartObject();
break;
case BionToken.StartArray:
writer.WriteStartArray();
break;
case BionToken.EndObject:
writer.WriteEndObject();
break;
case BionToken.EndArray:
writer.WriteEndArray();
break;
case BionToken.PropertyName:
writer.WritePropertyName(reader.CurrentString());
break;
case BionToken.String:
writer.WriteValue(reader.CurrentString());
break;
case BionToken.Integer:
writer.WriteValue(reader.CurrentInteger());
break;
case BionToken.Float:
writer.WriteValue(reader.CurrentFloat());
break;
case BionToken.True:
case BionToken.False:
writer.WriteValue(reader.CurrentBool());
break;
case BionToken.Null:
writer.WriteNull();
break;
default:
throw new NotImplementedException($"BionToJson not implemented for {reader.TokenType} @{reader.BytesRead}.");
}
}
/// <summary>
/// Writes the optional property.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
public static void WriteOptionalProperty(this JsonTextWriter writer, string name, object value, bool forceNullDefault = false)
{
if (value != null || forceNullDefault)
{
writer.WritePropertyName(name);
if (value != null)
{
writer.WriteValue(value);
}
else
{
writer.WriteNull();
}
}
}
public override void BeginWriteMessage(Request message)
{
writer = new JsonTextWriter();
Body[] body = message.getResponseBodies();
fault = (body.Length > 0 && body[0].ResponseDataObject is Exception);
writer.WriteStartObject();
// write out version
string version = (string)message.Headers[1].headerValue.defaultAdapt();
if (version == "1.1")
{
writer.WriteMember("version");
writer.WriteString("1.1");
}
else if (version == "2.0")
{
writer.WriteMember("jsonrpc");
writer.WriteString("2.0");
}
// if fault - modify error message to better comply JSON-RPC specification
if (fault)
{
body[0].responseDataObject = ProcessExceptionStack(version, (Exception)body[0].responseDataObject);
}
// hack: modify body if 'inspection' is ON to avoid cyclic references in ServiceDescriptor
//if( message.Headers.Length > 3 )
// body[ 0 ].responseDataObject = ((ServiceDescriptor) body[ 0 ].responseDataObject).functions;
// write out id if was present
if (message.getHeader("id").headerValue != null)
{
writer.WriteMember("id");
object id = message.getHeader("id").headerValue.defaultAdapt();
MessageWriter.writeObject(id, message.GetFormatter());
}
// only in version 1.0 was allowed to print out result:null on failure and error:null on successfull invocation
if (version == "1.0")
{
writer.WriteMember(fault ? "result" : "error");
writer.WriteNull();
}
writer.WriteMember(!fault ? "result" : "error");
}
private static void WriteClusterDocumentToSnapshot(JsonTextWriter jsonTextWriter, IStorageActionsAccessor accessor, string docName)
{
jsonTextWriter.WritePropertyName(docName);
var doc = accessor.Documents.DocumentByKey(docName);
if (doc != null)
{
var json = doc.ToJson();
json.WriteTo(jsonTextWriter);
}
else
{
jsonTextWriter.WriteNull();
}
}
public static void SerializeWriteRawObject(JsonTextWriter jsonTextWriter, string value)
{
JToken jToken = JToken.Parse(value);
JObject jObject = jToken as JObject;
JValue jValue = jToken as JValue;
JArray jArray = jToken as JArray;
if (jValue != null)
{
if (jValue.Value != null)
{
jsonTextWriter.WriteValue(jValue.Value);
}
else
{
jsonTextWriter.WriteNull();
}
return;
}
if (jArray != null)
{
jsonTextWriter.WriteStartArray();
for (int i = 0; i < jArray.Count; i++)
{
SerializeWriteRawObject(jsonTextWriter, jArray[i].ToString(Formatting.None));
}
jsonTextWriter.WriteEndArray();
return;
}
if (jObject == null)
{
jsonTextWriter.WriteRawValue(value);
return;
}
IList <string> keys = jObject.Properties().Select(p => p.Name).ToList();
jsonTextWriter.WriteStartObject();
foreach (string key in keys)
{
jsonTextWriter.WritePropertyName(key);
SerializeWriteRawObject(jsonTextWriter, jObject[key].ToString(Formatting.None));
}
jsonTextWriter.WriteEndObject();
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var streamWriter = new StreamWriter(stream);
var writer = new JsonTextWriter(streamWriter);
writer.WriteStartArray();
foreach (var result in results)
{
if (result == null)
{
writer.WriteNull();
continue;
}
writer.WriteStartObject();
writer.WritePropertyName("Status");
writer.WriteValue((int)result.StatusCode);
writer.WritePropertyName("Headers");
writer.WriteStartObject();
foreach (var header in result.Headers.Concat(result.Content.Headers))
{
foreach (var val in header.Value)
{
writer.WritePropertyName(header.Key);
writer.WriteValue(val);
}
}
writer.WriteEndObject();
writer.WritePropertyName("Result");
var jsonContent = (JsonContent)result.Content;
if (jsonContent.Data != null)
{
jsonContent.Data.WriteTo(writer, Default.Converters);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.Flush();
return(new CompletedTask());
}
private static string RowToJson(HashSet <string> columns, CsvTable.Row row, string doctype)
{
var buffer = new StringWriter();
var writer = new JsonTextWriter(buffer);
writer.WriteStartObject();
if (doctype != null)
{
writer.WritePropertyName("doctype");
writer.WriteValue(doctype);
}
var empty = true;
for (var i = 0; i < row.Table.Headers.Length; ++i)
{
if ((columns != null) && !columns.Contains(row.Table.Headers[i]))
{
continue;
}
empty = false;
writer.WritePropertyName(row.Table.Headers[i]);
var value = row[i];
double number;
if (double.TryParse(value, out number))
{
if (double.IsNaN(number) || double.IsInfinity(number))
{
writer.WriteNull();
}
else
{
writer.WriteRawValue(value);
}
}
else
{
writer.WriteValue(value);
}
}
if (empty)
{
return(null);
}
writer.WriteEndObject();
return(buffer.ToString());
}
public static bool SerializeObjectNoPropertyName(JsonTextWriter jsonTextWriter, object value)
{
if (SerializeArrayNoPropertyName(jsonTextWriter, value))
{
return(true);
}
if (SerializePrimitiveNoPropertyName(jsonTextWriter, value))
{
return(true);
}
if (value == null)
{
jsonTextWriter.WriteNull();
return(true);
}
SerializeFull(jsonTextWriter, value);
return(true);
}
public static void SerializeMessage(JsonTextWriter writer, ServiceType type, object message)
{
Require.NotNull(writer, "writer");
Require.NotNull(type, "type");
Require.NotNull(message, "message");
writer.WriteStartObject();
foreach (var field in type.Fields.Values)
{
if (
field.ShouldSerializeMethod != null &&
!field.ShouldSerializeMethod(message)
)
continue;
writer.WritePropertyName(field.Tag.ToString(CultureInfo.InvariantCulture));
object value = field.Getter(message);
if (value == null)
{
writer.WriteNull();
}
else if (field.CollectionType != null)
{
writer.WriteStartArray();
foreach (object item in (IEnumerable)value)
{
if (field.ServiceType != null && !field.ServiceType.Type.IsEnum)
SerializeMessage(writer, field.ServiceType, item);
else
writer.WriteValue(item);
}
writer.WriteEndArray();
}
else
{
if (field.ServiceType != null && !field.ServiceType.Type.IsEnum)
SerializeMessage(writer, field.ServiceType, value);
else
writer.WriteValue(value);
}
}
writer.WriteEndObject();
}
void SaveConfigInternal(JsonTextWriter writer, TimelineBase timelines)
{
foreach (object item in timelines.TimeLines) {
writer.WriteStartObject ();
writer.WriteKey ("type");
TimelineInfo tl = item as TimelineInfo;
TabInfo tb = item as TabInfo;
if (tl != null) {
if (tl.Search != null) {
writer.WriteString ("search");
writer.WriteKey ("keywords");
writer.WriteString (tl.Search.Keyword);
} else if (tl.List != null) {
writer.WriteString ("list");
writer.WriteKey ("id");
writer.WriteNumber (tl.List.List.ID);
} else {
writer.WriteString ("account");
writer.WriteKey ("subtype");
if (tl.Statuses == tl.RestAccount.HomeTimeline)
writer.WriteString ("home");
else if (tl.Statuses == tl.RestAccount.Mentions)
writer.WriteString ("mentions");
else if (tl.Statuses == tl.RestAccount.DirectMessages)
writer.WriteString ("directmessages");
writer.WriteKey ("name");
writer.WriteString (tl.RestAccount.ScreenName);
}
} else if (tb != null) {
writer.WriteString ("tab");
writer.WriteKey ("title");
writer.WriteString (tb.Title);
writer.WriteKey ("windows");
writer.WriteStartArray ();
SaveConfigInternal (writer, tb);
writer.WriteEndArray ();
} else {
writer.WriteNull ();
}
writer.WriteEndObject ();
}
}
void WriteAccount(JsonTextWriter writer, TwitterAccount account)
{
writer.WriteStartObject ();
if (account.Credential is NetworkCredential) {
NetworkCredential nc = account.Credential as NetworkCredential;
writer.WriteKey ("username");
writer.WriteString (nc.UserName);
writer.WriteKey ("password");
writer.WriteString (nc.Password);
} else if (account.Credential is OAuthPasswordCache) {
OAuthPasswordCache pc = account.Credential as OAuthPasswordCache;
writer.WriteKey ("username");
writer.WriteString (pc.UserName);
writer.WriteKey ("password");
writer.WriteString (pc.Password);
writer.WriteKey ("token");
writer.WriteString (pc.AccessToken);
writer.WriteKey ("secret");
writer.WriteString (pc.AccessSecret);
}
if (account.SelfUserID > 0) {
writer.WriteKey ("id");
writer.WriteNumber (account.SelfUserID);
}
writer.WriteKey ("rest");
writer.WriteStartObject ();
string[] rest_keys = new string[] {"home", "mentions", "dm"};
TwitterAccount.RestUsage[] rests = new TwitterAccount.RestUsage[] {account.RestHome, account.RestMentions, account.RestDirectMessages};
for (int i = 0; i < rest_keys.Length; i ++) {
writer.WriteKey (rest_keys[i]);
writer.WriteStartObject ();
writer.WriteKey ("enable");
writer.WriteBoolean (rests[i].IsEnabled);
writer.WriteKey ("count");
writer.WriteNumber (rests[i].Count);
writer.WriteKey ("interval");
writer.WriteNumber ((int)rests[i].Interval.TotalSeconds);
writer.WriteEndObject ();
}
writer.WriteEndObject ();
writer.WriteKey ("streaming");
if (account.StreamingClient == null) {
writer.WriteNull ();
} else {
writer.WriteStartObject ();
writer.WriteKey ("mode");
if (account.StreamingClient.Target is TwitterAccount) {
writer.WriteString ("follow");
writer.WriteKey ("username");
writer.WriteString ((account.StreamingClient.Target as TwitterAccount).ScreenName);
} else if (account.StreamingClient.Target is SearchStatuses) {
writer.WriteString ("track");
writer.WriteKey ("keywords");
writer.WriteString (account.StreamingClient.SearchKeywords);
} else if (account.StreamingClient.Target is ListStatuses) {
writer.WriteString ("list");
writer.WriteKey ("id");
writer.WriteNumber ((account.StreamingClient.Target as ListStatuses).List.ID);
}
writer.WriteEndObject ();
}
writer.WriteEndObject ();
}
protected override void ProcessRequest()
{
string httpMethod = Request.RequestType;
if (!CaselessString.Equals(httpMethod, "GET") &&
!CaselessString.Equals(httpMethod, "HEAD"))
{
throw new JsonRpcException(string.Format("HTTP {0} is not supported for RPC execution. Use HTTP GET or HEAD only.", httpMethod));
}
//
// Response will be plain text, though it would have been nice to
// be more specific, like text/json.
//
Response.ContentType = "text/plain";
//
// Convert the query string into a call object.
//
JsonWriter writer = new JsonTextWriter();
writer.WriteStartObject();
writer.WriteMember("id");
writer.WriteNumber(0);
writer.WriteMember("method");
string methodName = Mask.NullString(Request.PathInfo);
if (methodName.Length == 0)
writer.WriteNull();
else
writer.WriteString(methodName.Substring(1));
writer.WriteMember("params");
writer.WriteStartObject();
NameValueCollection query = Request.QueryString;
if (query.HasKeys())
{
foreach (string name in query)
{
if (Mask.NullString(name).Length == 0)
continue;
writer.WriteMember(name);
string[] values = query.GetValues(name);
if (values.Length == 0)
writer.WriteNull();
else if (values.Length == 1)
writer.WriteString(values[0]);
else
writer.WriteArray(values);
}
}
writer.WriteEndObject();
writer.WriteEndObject();
//
// Delegate rest of the work to JsonRpcDispatcher.
//
JsonRpcDispatcher dispatcher = new JsonRpcDispatcher(Service);
if (HttpRequestSecurity.IsLocal(Request))
dispatcher.SetLocalExecution();
dispatcher.Process(new StringReader(writer.ToString()), Response.Output);
}
