private static string NewtonsoftDecode(string input)
{
var sr = new StringReader(input);
var reader = new JsonTextReader(sr);
var output = reader.ReadAsString();
reader.Close();
return output;
}
public void DeserializeRequest(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
(bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
}
var bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
var rawBody = bodyReader.ReadContentAsBase64();
var ms = new MemoryStream(rawBody);
var sr = new StreamReader(ms);
var serializer = CreateJsonSerializer(); // new JsonSerializer();
if (parameters.Length == 1)
{
// single parameter, assuming bare
parameters[0] = serializer.Deserialize(sr, _operation.Messages[0].Body.Parts[0].Type);
}
else
{
// multiple parameter, needs to be wrapped
JsonReader reader = new Newtonsoft.Json.JsonTextReader(sr);
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
{
throw new InvalidOperationException("Input needs to be wrapped in an object");
}
reader.Read();
while (reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName)
{
var parameterName = reader.Value as string;
reader.Read();
if (_parameterNames.ContainsKey(parameterName))
{
var parameterIndex = _parameterNames[parameterName];
parameters[parameterIndex] = serializer.Deserialize(reader, _operation.Messages[0].Body.Parts[parameterIndex].Type);
}
else
{
reader.Skip();
}
reader.Read();
}
reader.Close();
}
sr.Close();
ms.Close();
}
public static void Load(string path)
{
JsonTextReader reader = new JsonTextReader(new StreamReader(path));
JsonSerializer serializer = new JsonSerializer();
instance = serializer.Deserialize<BotConfig>(reader);
reader.Close();
}
private static ModelList ReadFile()
{
var filePath = string.Format("c:\\models.json");
var reader = new StreamReader(filePath);
var jsonReader = new JsonTextReader(reader);
var serializer = new JsonSerializer();
var modelList = serializer.Deserialize<ModelList>(jsonReader);
jsonReader.Close();
return modelList;
}
private static void InitializePopulation(string inputFile, string populationSize)
{
var jsSerializer = new JsonSerializer();
var textReader = new StreamReader(inputFile);
var reader = new JsonTextReader(textReader);
var cfg = jsSerializer.Deserialize<Configuration>(reader);
textReader.Close();
reader.Close();
Runner = new Runner(cfg, int.Parse(populationSize));
Console.WriteLine("Initialized");
Console.WriteLine("Best table score is: " + Runner.BestScore());
}
public void CloseInput()
{
MemoryStream ms = new MemoryStream();
JsonTextReader reader = new JsonTextReader(new StreamReader(ms));
Assert.IsTrue(ms.CanRead);
reader.Close();
Assert.IsFalse(ms.CanRead);
ms = new MemoryStream();
reader = new JsonTextReader(new StreamReader(ms)) { CloseInput = false };
Assert.IsTrue(ms.CanRead);
reader.Close();
Assert.IsTrue(ms.CanRead);
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonInterpreter"/> class.
/// </summary>
/// <param name="source">The <see cref="IResource"/>.</param>
public JsonInterpreter(IResource source) : base(source)
{
string xmlContents = string.Empty;
using(source)
{
JsonReader reader = new JsonTextReader(new StreamReader(source.Stream));
reader.Read();
XmlNodeConverter toXml = new XmlNodeConverter();
XmlDocument xmlDoc = (XmlDocument)toXml.ReadJson(reader, typeof(XmlDocument));
xmlContents = xmlDoc.OuterXml;
reader.Close();
}
IResource resource = new StaticContentResource(xmlContents);
xmlInterpreter = new XmlConfigurationInterpreter(resource);
}
public async Task GetNextTopPosts(Action<List<Post>> callback)
{
if (NextTopPosts == "/news3")
{
callback(new List<Post>());
return;
}
HttpWebRequest request = HttpWebRequest.Create("http://" + serverAddress + NextTopPosts) as HttpWebRequest;
request.Accept = "application/json";
var response = await request.GetResponseAsync().ConfigureAwait(false);
Stream stream = response.GetResponseStream();
UTF8Encoding encoding = new UTF8Encoding();
StreamReader sr = new StreamReader(stream, encoding);
JsonTextReader tr = new JsonTextReader(sr);
List<Post> data = new JsonSerializer().Deserialize<List<Post>>(tr);
tr.Close();
sr.Dispose();
stream.Dispose();
foreach (var item in data)
{
item.title = CleanTitleText(item.title);
item.is_read = PostHistory.Contains(item.id);
if (item.url.StartsWith("http") == false)
item.url = "http://news.ycombinator.com/item?id=" + item.id;
}
for (int i = 0; i < data.Count; i++)
{
data[i] = FormatPost(data[i]);
}
int index = NextTopPosts == "/news" ? 2 : Convert.ToInt32(NextTopPosts.Replace("/news", "")) + 1;
NextTopPosts = "/news" + index;
callback(data);
}
/// <summary>
/// Parse a string, and deserialize it into the supplied object.
/// </summary>
/// <param name="Object">The MudObject to write deserialized data to</param>
/// <param name="Data"></param>
internal static void DeserializeObject(MudObject Object, String Data)
{
var persistentProperties = new List<Tuple<System.Reflection.PropertyInfo, PersistAttribute>>(EnumeratePersistentProperties(Object));
var jsonReader = new JsonTextReader(new System.IO.StringReader(Data));
jsonReader.Read();
jsonReader.Read();
while (jsonReader.TokenType != JsonToken.EndObject)
{
var propertyName = jsonReader.Value.ToString();
var prop = persistentProperties.FirstOrDefault(t => t.Item1.Name == propertyName);
if (prop == null) throw new InvalidOperationException();
jsonReader.Read();
prop.Item1.SetValue(Object, prop.Item2.ReadValue(prop.Item1.PropertyType, jsonReader, Object), null);
}
jsonReader.Close();
}
public void GetDateJson(DateTime date, Action<ApiModel.Rootobject> success, Action<Exception> error)
{
string url = "http://www.someEventsWebsite.com"; // Obviously fake...
Action<string> parseAndAddToDb = text =>
{
using (var stringReader = new StringReader(text))
{
var converter = new JsonSerializer();
var jsonReader = new JsonTextReader(stringReader);
var rootobject = converter.Deserialize<ApiModel.Rootobject>(jsonReader);
_apiModelCacheService.AddDateModel(date, rootobject);
success(rootobject);
jsonReader.Close();
}
};
_downloaderService.Download(url, parseAndAddToDb, error);
}
public object DeSerialize(string value, Type type)
{
JsonSerializer json = new Newtonsoft.Json.JsonSerializer();
json.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
json.ObjectCreationHandling = Newtonsoft.Json.ObjectCreationHandling.Replace;
json.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
json.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
json.Converters.Add(new EnumerableConverter());
StringReader sr = new StringReader(value);
Newtonsoft.Json.JsonTextReader reader = new Newtonsoft.Json.JsonTextReader(sr);
object result = null;
result = type == null?Newtonsoft.Json.JsonConvert.DeserializeObject(value) : json.Deserialize(reader, type);
reader.Close();
return(result);
}
/// <summary>
/// Populates the recordset.
/// </summary>
public void PopulateFormList( )
{
try
{
string requesturl = _url;
WebResponse webResponse = Utilities.DownloadRequest(requesturl, _username, _password);
Encoding enc = Encoding.Default;
string configuration = String.Empty;
using (StreamReader reader = new StreamReader(webResponse.GetResponseStream()))
{
configuration = reader.ReadToEnd();
}
Debug.WriteLine(configuration);
Newtonsoft.Json.JsonSerializer json = new Newtonsoft.Json.JsonSerializer();
json.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
json.ObjectCreationHandling = Newtonsoft.Json.ObjectCreationHandling.Replace;
json.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
json.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
StringReader sr = new StringReader(configuration);
Newtonsoft.Json.JsonTextReader jReader = new JsonTextReader(sr);
Newtonsoft.Json.Linq.JArray result = (Newtonsoft.Json.Linq.JArray)json.Deserialize(jReader, Type.GetType("System.Data.DataSet"));
//Get the Record Set
jReader.Close();
List<FormResult> results = new List<FormResult>();
return;
}
catch (Exception ex)
{
throw ex;
}
}
public static void Main(string[] args)
{
WebClient client = new WebClient();
foreach (string album in args)
{
Console.WriteLine("Retrieving album info..." /* from " + album + "..."*/);
HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(album);
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
Stream dataStream = resp.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
List<string> page = new List<string>();
while (!reader.EndOfStream)
page.Add(reader.ReadLine());
reader.Close();
dataStream.Close();
resp.Close();
int albumdatastart = page.IndexOf("var TralbumData = {");
int albumdataend = page.IndexOf("};", albumdatastart);
string jsondata = "{";
for (int i = albumdatastart + 4; i < albumdataend; i++)
jsondata += page[i];
jsondata += " }";
StringReader sr = new StringReader(jsondata);
JsonTextReader jr = new JsonTextReader(sr);
JsonSerializer js = new JsonSerializer();
TralbumData data = js.Deserialize<TralbumData>(jr);
jr.Close();
sr.Close();
string albumPath = data.current.title;
foreach (char item in Path.GetInvalidPathChars())
albumPath = albumPath.Replace(item, '_');
albumPath = albumPath.Replace(": ", " - ");
albumPath = Path.Combine(Environment.CurrentDirectory, albumPath);
Directory.CreateDirectory(albumPath);
Console.WriteLine("Found " + data.trackinfo.Length + " tracks in album \"" + data.current.title + "\"...");
client.DownloadFile(data.artFullsizeUrl, Path.Combine(albumPath, "art.png"));
string hostname = new Uri(album).Host;
for (int i = 0; i < data.trackinfo.Length; i++)
{
Console.Write("Downloading track \"" + data.trackinfo[i].title + "\" (" + (i + 1) + "/" + data.trackinfo.Length + ")...");
string filePath = data.trackinfo[i].title;
if (data.trackinfo.Length < 100)
{
filePath = (i + 1).ToString("D2") + " - " + filePath;
}
else
{
filePath = (i + 1).ToString("D3") + " - " + filePath;
}
foreach (char item in Path.GetInvalidFileNameChars())
filePath = filePath.Replace(item, '_');
filePath = filePath.Replace(": ", " - ").Replace('/', '-').Replace('\\', '-');
filePath = Path.ChangeExtension(Path.Combine(albumPath, filePath), "mp3");
client.DownloadFile(data.trackinfo[i].file["mp3-128"], filePath);
IdSharp.Tagging.ID3v2.ID3v2Tag tag = new IdSharp.Tagging.ID3v2.ID3v2Tag(filePath);
tag.Album = data.current.title;
tag.AlbumArtist = tag.Artist = data.artist;
IdSharp.Tagging.ID3v2.Frames.IAttachedPicture pic = tag.PictureList.AddNew();
pic.Picture = System.Drawing.Image.FromFile(Path.Combine(albumPath, "art.png"));
if (data.trackinfo[i].has_info != null)
{
IdSharp.Tagging.ID3v2.Frames.IComments com = tag.CommentsList.AddNew();
com.Value = data.trackinfo[i].has_info;
}
tag.ReleaseTimestamp = data.current.release_date_datetime.ToString("s", System.Globalization.DateTimeFormatInfo.InvariantInfo);
tag.Title = data.trackinfo[i].title;
tag.TrackNumber = (i + 1).ToString(System.Globalization.NumberFormatInfo.InvariantInfo);
tag.Year = data.current.release_date_datetime.Year.ToString("0000", System.Globalization.NumberFormatInfo.InvariantInfo);
tag.CommercialInfoUrlList.AddNew().Value = album;
tag.AudioFileUrl = "http://" + hostname + data.trackinfo[i].title_link;
tag.ArtistUrlList.AddNew().Value = "http://" + hostname + "/";
tag.Save(filePath);
Console.WriteLine(" downloaded!");
}
File.WriteAllText(Path.Combine(albumPath, "Info.txt"), data.current.title + " by " + data.artist + "\r\nReleased " + data.current.release_date_datetime.ToString() + "\r\n" + data.current.about + "\r\n" + data.current.credits);
}
}
public static object Deserialize(string jsonText, Type valueType)
{
Newtonsoft.Json.JsonSerializer json = new Newtonsoft.Json.JsonSerializer();
json.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
json.ObjectCreationHandling = Newtonsoft.Json.ObjectCreationHandling.Replace;
json.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
json.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
StringReader sr = new StringReader(jsonText);
Newtonsoft.Json.JsonTextReader reader = new JsonTextReader(sr);
object result = json.Deserialize(reader, valueType);
reader.Close();
return result;
}
public async Task<bool> GetUserDataAsync()
{
IsLoading = true;
String strContent = await ViewModelLocator.Client.MakeOperationAsync(SupportedModules.USER,
SupportedMethods.GetUserData);
if (strContent != "")
{
User connectedUser = JsonConvert.DeserializeObject<User>(strContent);
StringReader str = new StringReader(strContent);
String institution = "";
String platform = "";
JsonTextReader reader = new JsonTextReader(str);
while (reader.Read())
{
if (reader.Value != null)
{
switch (reader.Value.ToString())
{
case "institutionName":
institution = reader.ReadAsString();
break;
case "platformName":
platform = reader.ReadAsString();
break;
default:
continue;
}
}
}
reader.Close();
str.Close();
Settings.UserSetting.setUser(connectedUser);
Settings.InstituteSetting = institution;
Settings.PlatformSetting = platform;
IsLoading = false;
return true;
}
IsLoading = false;
return false;
}
public void DeserializeRequest(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
(bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
}
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] rawBody = bodyReader.ReadContentAsBase64();
MemoryStream ms = new MemoryStream(rawBody);
StreamReader sr = new StreamReader(ms);
JsonSerializer serializer = new JsonSerializer
{
PreserveReferencesHandling = PreserveReferencesHandling.Objects
};
if (parameters.Length == 1)
{
// single parameter, assuming bare
parameters[0] = serializer.Deserialize(sr, this.operation.Messages[0].Body.Parts[0].Type);
}
else
{
// multiple parameter, needs to be wrapped
JsonReader reader = new JsonTextReader(sr);
reader.Read();
if (reader.TokenType != JsonToken.StartObject)
{
throw new InvalidOperationException("Input needs to be wrapped in an object");
}
reader.Read();
while (reader.TokenType == JsonToken.PropertyName)
{
string parameterName = reader.Value as string;
reader.Read();
if (this.parameterNames.ContainsKey(parameterName))
{
int parameterIndex = this.parameterNames[parameterName];
parameters[parameterIndex] = serializer.Deserialize(reader, this.operation.Messages[0].Body.Parts[parameterIndex].Type);
}
else
{
reader.Skip();
}
reader.Read();
}
reader.Close();
}
sr.Close();
ms.Close();
}
private void testSingleJsonResource(string jsonFile)
{
Support.ErrorList errors = new Support.ErrorList();
Model.Resource singleResult;
using (JsonTextReader jr = new JsonTextReader(new System.IO.StreamReader(jsonFile)))
{
Debug.WriteLine(" Reading from json...");
singleResult = FhirParser.ParseResource(jr, errors);
jr.Close();
}
if (errors.Count > 0)
{
Debug.WriteLine("=== Json Parse errors ===" + Environment.NewLine + errors.ToString());
_roundTripFailed = true;
}
else
{
string xmlFile = Path.ChangeExtension(jsonFile, ".xml");
using (XmlWriter xw = new XmlTextWriter(new System.IO.StreamWriter(xmlFile)))
{
Debug.WriteLine(" Writing xml...");
FhirSerializer.SerializeResource(singleResult, xw);
}
}
}
private void LoadDetails(IsolatedStorageFile store)
{
using (var fs = store.OpenFile(InfoPath, FileMode.Open))
{
var serializer = new JsonSerializer();
var reader = new JsonTextReader(
new StreamReader(fs));
var details = serializer.Deserialize
<DatabaseDetails>(reader);
Details = details;
reader.Close();
}
}
/// <summary>
/// Loads a list from a json file and returns a hashtable for each record
/// </summary>
public static List<Hashtable> RecordsFromFile(string file)
{
string path = StorageContainer.TitleLocation + file;
System.IO.TextReader reader = new System.IO.StreamReader(path);
List<Hashtable> list = new List<Hashtable>();
Hashtable cur = null;
// Read through each object in the file
JsonTextReader json = new JsonTextReader(reader);
while (json.Read())
{
if (json.Value == null && (json.TokenType == JsonToken.StartObject || json.TokenType == JsonToken.EndObject))
{
json.Read();
if (json.TokenType == JsonToken.PropertyName)
{
if (cur != null) list.Add(cur);
cur = new Hashtable();
cur["name"] = (string)json.Value;
json.Read();
}
}
else if (json.TokenType == JsonToken.PropertyName)
{
string val = (string)json.Value;
json.Read();
cur[val] = json.Value;
}
}
// Add the last record
if (cur != null) list.Add(cur);
json.Close();
return list;
}
private void saveToJson(string fileUrn, string tags, string filename)
{
var filePath = string.Format("c:\\models.json");
var reader = new StreamReader(filePath);
var jsonReader = new JsonTextReader(reader);
var serializer = new JsonSerializer();
var modelList = serializer.Deserialize<ModelList>(jsonReader);
jsonReader.Close();
if (modelList == null)
{
modelList = new ModelList{Models = new List<Model>()};
}
if (modelList.Models.All(x => x.FileUrn != fileUrn))
{
var model = new Model { FileUrn = fileUrn, Tags = tags, FileName = filename };
modelList.Models.Add(model);
}
var writer = new StreamWriter(filePath);
var jsonWriter = new JsonTextWriter(writer);
var ser = new JsonSerializer();
ser.Serialize(jsonWriter, modelList);
jsonWriter.Flush();
}
private void Read(JsonTextReader reader)
{
var hasStuff = reader.Read();
if (hasStuff)
{
if (!_started)
{
_started = true;
(this as IEventEmitter).Raise("start", new object[] { this });
}
switch (reader.TokenType)
{
case JsonToken.StartObject:
break;
case JsonToken.EndObject:
break;
case JsonToken.StartArray:
break;
case JsonToken.EndArray:
break;
case JsonToken.Boolean:
break;
case JsonToken.Bytes:
break;
case JsonToken.Date:
break;
case JsonToken.Float:
break;
case JsonToken.Integer:
break;
case JsonToken.PropertyName:
break;
case JsonToken.Null:
break;
case JsonToken.Raw:
break;
case JsonToken.String:
break;
}
Read(reader);
}
else
{
reader.Close();
(this as IEventEmitter).Raise("end", new object[]{ this });
}
}
private void LoadConfiguration()
{
if(!File.Exists(_file))
return;
_lock.EnterWriteLock();
try
{
using(TextReader textReader = new StreamReader(_file))
{
JsonTextReader reader = new JsonTextReader(textReader);
_storage = JObject.Load(reader);
reader.Close();
}
}
finally
{
_lock.ExitWriteLock();
}
}
public static Envelope Deserialize(byte[] body)
{
Envelope env = null;
MemoryStream baseStream = new MemoryStream(body);
JsonSerializer ser = new JsonSerializer();
using (StreamReader reader = new StreamReader(baseStream, new UTF8Encoding()))
{
using (JsonTextReader jsonReader = new JsonTextReader(reader))
{
env = ser.Deserialize<Envelope>(jsonReader);
jsonReader.Close();
}
reader.Close();
}
return env;
}
public async Task GetComments(Action<CommentResponse> callback, string postId)
{
HttpWebRequest request = HttpWebRequest.Create("http://" + serverAddress + "/item/" + postId) as HttpWebRequest;
request.Accept = "application/json";
var response = await request.GetResponseAsync().ConfigureAwait(false);
Stream stream = response.GetResponseStream();
UTF8Encoding encoding = new UTF8Encoding();
StreamReader sr = new StreamReader(stream, encoding);
JsonTextReader tr = new JsonTextReader(sr);
CommentResponse data = new JsonSerializer().Deserialize<CommentResponse>(tr);
tr.Close();
sr.Dispose();
stream.Dispose();
if (data.url.StartsWith("http") == false)
data.url = "http://news.ycombinator.com/item?id=" + data.id;
data = FormatCommentPost(data);
if (data.content != null)
{
Comment child = new Comment();
child.comments = new List<Comment>();
child.content = data.content;
child.id = null;
child.level = 0;
child.time_ago = data.time_ago;
child.title = data.user + " " + data.time_ago;
child.user = data.user;
data.comments.Insert(0, child);
}
int i = data.comments.Count - 1;
while (i >= 0)
{
data.comments[i] = CleanCommentText(data.comments[i]);
data.comments[i] = FormatComment(data.comments[i]);
i--;
}
callback(data);
}
public void GenerateClasses(string nameSpace)
{
var numSamples = NumRowsToSample;
_generatedClasses =
GetInputFiles()
.Select(f =>
{
// TODO: Be a better error handler
try
{
var fs = new FileStream(f, FileMode.Open);
var sr = new StreamReader(fs);
var jtr = new JsonTextReader(sr);
var examples =
Enumerable
.Range(0, numSamples)
.Select(_ =>
{
while (jtr.Read())
if (jtr.TokenType == JsonToken.StartObject)
return JObject.Load(jtr).ToString();
return null;
})
.Where(json => json != null);
var examplesJson = String.Format("[{0}]", String.Join(",\r\n", examples));
jtr.Close();
sr.Close();
fs.Close();
var className = Path.GetFileNameWithoutExtension(f).SanitiseClassName();
var finalNamespace = nameSpace + "." + className + "Input";
var outputStream = new MemoryStream();
var outputWriter = new StreamWriter(outputStream);
var jsg = new JsonClassGenerator
{
Example = examplesJson,
Namespace = finalNamespace,
MainClass = className,
OutputStream = outputWriter,
NoHelperClass = true,
UseProperties = true,
GeneratePartialClasses = true
};
jsg.GenerateClasses();
outputWriter.Flush();
outputStream.Seek(0, SeekOrigin.Begin);
var classDef = new StreamReader(outputStream)
.ReadToEnd()
.Replace("IList<", "List<");
classDef =
classDef.Substring(classDef.IndexOf(String.Format("namespace {0}", nameSpace),
StringComparison.Ordinal));
NamespacesToAdd.Add(finalNamespace);
return new JsonFileGeneratedClass(this)
{
Namespace = finalNamespace,
ClassName = className,
DataFilePath = f,
ClassDefinition = classDef,
Success = true
};
}
catch (Exception e)
{
return new JsonFileGeneratedClass(this)
{
DataFilePath = f,
Success = false,
Error = e
};
}
})
.ToList();
}
private async Task TransformToSDataPayload(Stream targetStream)
{
using (var oContentStream = await originalContent.ReadAsStreamAsync())
{
JsonReader reader = null;
JsonWriter outStream = null;
int level = -1;
try
{
reader = new JsonTextReader(new StreamReader(oContentStream));
outStream = new JsonTextWriter(new StreamWriter(targetStream));
int respContentType = GetContentType();
bool searchForCollection = respContentType == ContentOdataCollection
|| respContentType == ContentApiCollection;
while (reader.Read())
{
if (searchForCollection && level == 0 && reader.TokenType == JsonToken.PropertyName)
{
if ((string)reader.Value == ParamCollectionNameApi || (string)reader.Value == ParamCollectionNameOdata)
{
WritePagingProperties(outStream);
outStream.WritePropertyName(ParamCollectionNameSdata);
}
else if ((string)reader.Value == ParamTotalresultOdata)
outStream.WritePropertyName(ParamTotalresultSdata);
else
outStream.WriteToken(reader, false);
}
else if (reader.TokenType == JsonToken.PropertyName)
outStream.WritePropertyName(CallOptionalMaps((string)reader.Value));
else
{
if (reader.TokenType == JsonToken.StartObject)
level++;
else if (reader.TokenType == JsonToken.EndObject)
level--;
outStream.WriteToken(reader, false);
}
}
outStream.Flush();
}
catch (Exception e)
{
// TODO can we get the user and tenant context from here?
}
finally
{
if (reader != null)
reader.Close();
if (outStream != null)
outStream.Close();
}
}
}
private void checkButton_Click(object sender, EventArgs e)
{
if (jsonLocation == null || tileLocation == null)
{
MessageBox.Show(@"Error! Please point the program to both your tile_config.json and your \data\json\ folder");
}
else
{
writing = new List<string>();
status.Text = "Status: Reading tile_config.json";
sr1 = new StreamReader(tileLocation);
JsonReader reader = new JsonTextReader(sr1);
JObject o1 = (JObject)JToken.ReadFrom(reader);
reader.Close();
sr1.Close();
array = (JArray)o1["tiles"];
reader.Close();
tileID = new List<string>();
for (int i = 0; i < array.Count; i++)
{
tileID.Add((string)array[i]["id"]);
}
foreach (String s in jsonFiles)
{
status.Text = "Status: Reading " + s;
filepath = jsonLocation + s;
Console.WriteLine(filepath);
sr1 = new StreamReader(filepath);
json = sr1.ReadToEnd();
sr1.Close();
array = JArray.Parse(json);
for (int i = 0; i < array.Count; i++)
{
bool found = false;
string id = (string)array[i]["id"];
if ((string)array[i]["type"] == "vehicle_part")
{
id = "vp_" + id;
}
foreach (string s1 in tileID)
{
if (!found)
{
if (s1 == id)
{
found = true;
}
}
}
if (!found)
{
writing.Add(id);
}
}
}
//Now to write the missing.txt
if (saveFile.ShowDialog() == DialogResult.OK)
{
status.Text = "Status: Writing missing.txt";
File.WriteAllText(saveFile.FileName, "");
StreamWriter writer = new StreamWriter(saveFile.FileName);
foreach (string s in writing)
{
writer.WriteLine(s);
}
writer.Close();
}
status.Text = "Status: Done!";
}
}
/// <summary>
/// Reads the internal global .json file of a given platform and
/// returns the unmarshalled database object.
/// </summary>
/// <returns>Deserialized object or empty database if no file exists or parsing error</returns>
private GlobalDatabase UnmarshallDatabase()
{
if (!File.Exists(_dbPath)) {
_logger.Info("Creating new global database, {0} not found.", _dbPath);
return null;
}
try {
using (var sr = new StreamReader(_dbPath))
using (JsonReader reader = new JsonTextReader(sr)) {
try {
var db = _serializer.Deserialize<GlobalDatabase>(reader);
reader.Close();
return db;
} catch (Exception e) {
_logger.Error(e, "Error parsing {0}, deleting and ignoring.", _dbPath);
_crashManager.Report(e, "json");
reader.Close();
File.Delete(_dbPath);
return null;
}
}
} catch (Exception e) {
_logger.Error(e, "Error reading {0}, deleting and ignoring.", _dbPath);
_crashManager.Report(e, "json");
return null;
}
}
public static string SyncJsonObjectTypes(string OldJson, string NewJson)
{
StringReader NSR = new StringReader(NewJson);
JsonTextReader New = new JsonTextReader(NSR);
StringReader OSR = new StringReader(OldJson);
JsonTextReader Old = new JsonTextReader(OSR);
StringWriter SW = new StringWriter();
JsonTextWriter Writer = new JsonTextWriter(SW);
while (New.Read() && Old.Read())
{
if ((Old.TokenType == JsonToken.Integer) && (New.TokenType != JsonToken.Integer))
{
int NewIntValue = 0;
if (Int32.TryParse(New.Value.ToString(), out NewIntValue))
{
Writer.WriteValue(NewIntValue);
}
else
{
Writer.WriteValue(New.Value);
}
}
else if ((Old.TokenType == JsonToken.Float) && (New.TokenType != JsonToken.Float))
{
float NewFloatValue = 0;
if (float.TryParse(New.Value.ToString(), out NewFloatValue))
{
Writer.WriteValue(NewFloatValue);
}
else
{
Writer.WriteValue(New.Value);
}
}
else if ((Old.TokenType == JsonToken.Boolean) && (New.TokenType != JsonToken.Boolean))
{
string Value = New.Value.ToString();
if (Value.Equals("true"))
{
Writer.WriteValue(true);
}
else if (Value.Equals("false"))
{
Writer.WriteValue(false);
}
else
{
Writer.WriteValue(New.Value);
}
}
else if ((Old.TokenType == JsonToken.String) && (New.TokenType == JsonToken.Null))
{
Writer.WriteValue("");
}
else if ((Old.TokenType == JsonToken.StartArray) && (New.TokenType == JsonToken.String))
{
Old.Read();
if (Old.TokenType == JsonToken.EndArray)
{
Writer.WriteValue(JsonToken.StartArray);
if (New.Value.ToString() != "") Writer.WriteValue(New.Value);
Writer.WriteValue(JsonToken.EndArray);
}
else
{
Writer.WriteValue(New.Value);
}
}
else
{
if (Old.TokenType != New.TokenType)
{
Writer.Close();
New.Close();
Old.Close();
return NewJson;
}
else if (New.TokenType == JsonToken.PropertyName)
{
if (Old.Value == null || New.Value == null)
{
Writer.Close();
New.Close();
Old.Close();
return NewJson;
}
else if (!Old.Value.ToString().Equals(New.Value.ToString()))
{
Writer.Close();
New.Close();
Old.Close();
return NewJson;
}
}
switch (New.TokenType)
{
case JsonToken.StartConstructor:
Writer.WriteStartConstructor("");
break;
case JsonToken.EndConstructor:
Writer.WriteEndConstructor();
break;
case JsonToken.StartObject:
Writer.WriteStartObject();
break;
case JsonToken.EndObject:
Writer.WriteEndObject();
break;
case JsonToken.StartArray:
Writer.WriteStartArray();
break;
case JsonToken.EndArray:
Writer.WriteEndArray();
break;
case JsonToken.PropertyName:
Writer.WritePropertyName(New.Value.ToString());
break;
case JsonToken.String:
case JsonToken.Integer:
case JsonToken.Boolean:
case JsonToken.Date:
case JsonToken.Null:
case JsonToken.Float:
Writer.WriteValue(New.Value);
break;
}
}
}
return SW.ToString();
}
/// <summary>
/// imports the data from the file into the database
/// (only newer data will be imported)
/// </summary>
/// <param name="fileName"></param>
public void ImportSystems(String Filename)
{
DBConnector lDBCon = null;
String sqlString;
List<EDSystem> Systems;
EDSystem importSystem;
dsEliteDB.tbsystemsRow[] FoundRows;
dsEliteDB.tbsystems_orgRow[] FoundRows_org;
DateTime Timestamp_new, Timestamp_old;
Int32 ImportCounter = 0;
Dictionary<Int32, Int32> changedSystemIDs = new Dictionary<Int32, Int32>();
dsEliteDB localDataSet;
Int32 counter = 0;
Boolean dataChanged;
localDataSet = new dsEliteDB();
Int32 updated = 0;
Int32 added = 0;
MySql.Data.MySqlClient.MySqlDataAdapter dataAdapter_sys = null;
MySql.Data.MySqlClient.MySqlDataAdapter dataAdapter_sysorg = null;
Int32 systemsTotal=0;
try
{
lDBCon = new DBConnector(Program.DBCon.ConfigData, true);
// gettin' some freaky performance
lDBCon.Execute("set global innodb_flush_log_at_trx_commit=2");
StreamReader rawDataStream;
JsonTextReader jsonReader;
JsonSerializer serializer = new JsonSerializer();
rawDataStream = new StreamReader(Filename);
jsonReader = new JsonTextReader(rawDataStream);
sendProgressEvent(new ProgressEventArgs() { Info="import systems...", NewLine = true } );
while (jsonReader.Read())
if((jsonReader.TokenType == JsonToken.StartObject) && (jsonReader.Depth == 1))
systemsTotal++;
jsonReader.Close();
rawDataStream.Close();
rawDataStream.Dispose();
rawDataStream = new StreamReader(Filename);
jsonReader = new JsonTextReader(rawDataStream);
while(jsonReader.Read())
{
if((jsonReader.TokenType == JsonToken.StartObject) && (jsonReader.Depth == 1))
{
dataChanged = false;
importSystem = serializer.Deserialize<EDSystem>(jsonReader);
localDataSet.Clear();
if(dataAdapter_sys != null)
{
dataAdapter_sys.Dispose();
dataAdapter_sys = null;
}
if(dataAdapter_sysorg != null)
{
dataAdapter_sysorg.Dispose();
dataAdapter_sysorg = null;
}
lDBCon.TableRead(String.Format("select * from tbSystems where id = {0} lock in share mode;", importSystem.Id), localDataSet.tbsystems, ref dataAdapter_sys);
//sqlString = "select * from tbSystems_org lock in share mode";
//lDBCon.TableRead(sqlString, Data.tbsystems_org);
if (localDataSet.tbsystems.Rows.Count > 0)
{
// system is existing
if ((bool)(localDataSet.tbsystems.Rows[0]["is_changed"]))
{
// data is changed by user - hold it ...
// ...and check table "tbSystems_org" for the original data
lDBCon.TableRead(String.Format("select * from tbSystems_org where id = {0} lock in share mode;", importSystem.Id), localDataSet.tbsystems_org, ref dataAdapter_sysorg);
if (localDataSet.tbsystems_org.Rows.Count > 0)
{
// system is in "tbSystems_org" existing - keep the newer version
Timestamp_old = (DateTime)(localDataSet.tbsystems_org.Rows[0]["updated_at"]);
Timestamp_new = DateTimeOffset.FromUnixTimeSeconds(importSystem.UpdatedAt).DateTime;
if (Timestamp_new > Timestamp_old)
{
// data from file is newer
CopyEDSystemToDataRow(importSystem, (DataRow)localDataSet.tbsystems_org.Rows[0], false, null, true);
ImportCounter += 1;
dataChanged = true;
}
}
}
else
{
// system is existing - keep the newer version
Timestamp_old = (DateTime)(localDataSet.tbsystems.Rows[0]["updated_at"]);
Timestamp_new = DateTimeOffset.FromUnixTimeSeconds(importSystem.UpdatedAt).DateTime;
if (Timestamp_new > Timestamp_old)
{
// data from file is newer
CopyEDSystemToDataRow(importSystem, localDataSet.tbsystems.Rows[0], false, null, true);
ImportCounter += 1;
dataChanged = true;
updated += 1;
}
}
}
else
{
if(dataAdapter_sys != null)
{
dataAdapter_sys.Dispose();
dataAdapter_sys = null;
}
// check if there's a user generated system
// self-created systems don't have the correct id so it must be identified by name
lDBCon.TableRead(String.Format("select * from tbSystems where systemname = {0} and id < 0 lock in share mode;", DBConnector.SQLAEscape(importSystem.Name.ToString()) ), localDataSet.tbsystems, ref dataAdapter_sys);
if (localDataSet.tbsystems.Rows.Count > 0)
{
// self created systems is existing -> correct id and get new data from EDDB
// (changed system_id in tbStations are automatically internal updated by the database itself)
CopyEDSystemToDataRow(importSystem, (DataRow)localDataSet.tbsystems.Rows[0], false, null, true);
dataChanged = true;
}
else
{
// add a new system
dsEliteDB.tbsystemsRow newRow = (dsEliteDB.tbsystemsRow)localDataSet.tbsystems.NewRow();
CopyEDSystemToDataRow(importSystem, (DataRow)newRow, false, null, true);
localDataSet.tbsystems.Rows.Add(newRow);
dataChanged = true;
}
added += 1;
ImportCounter += 1;
}
if(dataChanged)
{
if(localDataSet.tbsystems.Rows.Count > 0)
lDBCon.TableUpdate(localDataSet.tbsystems, dataAdapter_sys);
if(localDataSet.tbsystems_org.Rows.Count > 0)
lDBCon.TableUpdate(localDataSet.tbsystems_org, dataAdapter_sysorg);
dataChanged = false;
}
counter++;
if(sendProgressEvent(new ProgressEventArgs() { Info = String.Format("import systems : analysed={0}, updated={1}, added={2}", counter, ImportCounter-added, added), CurrentValue=counter, TotalValue=systemsTotal}))
break;
}
}
// reset freaky performance
lDBCon.Execute("set global innodb_flush_log_at_trx_commit=1");
lDBCon.Dispose();
}
catch (Exception ex)
{
if(lDBCon != null)
{
if (lDBCon.TransActive())
lDBCon.TransRollback();
try
{
// reset freaky performance
lDBCon.Execute("set global innodb_flush_log_at_trx_commit=1");
lDBCon.Dispose();
}
catch (Exception) { }
}
throw new Exception("Error while importing system data", ex);
}
}
public void ReadText(string text)
{
JsonReader r = new JsonTextReader(new StringReader(text));
r.Close();
}
public void DeserializeRequest(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
(bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
}
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] rawBody = bodyReader.ReadContentAsBase64();
MemoryStream ms = new MemoryStream(rawBody);
StreamReader sr = new StreamReader(ms);
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
if (parameters.Length == 1)
{
string contenido = sr.ReadToEnd();
if (contenido.StartsWith("{\"Querye\":"))
{
contenido = contenido.Substring("{\"Querye\":".Length);
contenido = contenido.Substring(0, contenido.Length - 1);
}
// single parameter, assuming bare
parameters[0] = JsonConvert.DeserializeObject(contenido, operation.Messages[0].Body.Parts[0].Type);
}
else
{
// multiple parameter, needs to be wrapped
Newtonsoft.Json.JsonReader reader = new Newtonsoft.Json.JsonTextReader(sr);
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
{
throw new InvalidOperationException("Input needs to be wrapped in an object");
}
reader.Read();
while (reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName)
{
string parameterName = reader.Value as string;
reader.Read();
if (this.parameterNames.ContainsKey(parameterName))
{
int parameterIndex = this.parameterNames[parameterName];
parameters[parameterIndex] = serializer.Deserialize(reader, this.operation.Messages[0].Body.Parts[parameterIndex].Type);
}
else
{
reader.Skip();
}
reader.Read();
}
reader.Close();
}
sr.Close();
ms.Close();
}
public PlatformDatabase UnmarshallPlatformDatabase(string databaseFile)
{
if (!File.Exists(databaseFile)) {
return new PlatformDatabase();
}
_logger.Info("Reading game database from {0}...", databaseFile);
try {
using (var sr = new StreamReader(databaseFile))
using (JsonReader reader = new JsonTextReader(sr)) {
try {
var db = _serializer.Deserialize<PlatformDatabase>(reader);
reader.Close();
return db ?? new PlatformDatabase();
} catch (Exception e) {
_logger.Error(e, "Error parsing vpdb.json, deleting and ignoring.");
_crashManager.Report(e, "json");
reader.Close();
File.Delete(databaseFile);
return new PlatformDatabase();
}
}
} catch (Exception e) {
_logger.Error(e, "Error reading vpdb.json, deleting and ignoring.");
_crashManager.Report(e, "json");
return new PlatformDatabase();
}
}
