private InsultDataSource LoadSource(string path)
{
JObject obj = JSONSerialization.LoadAsJObject(path);
if (obj == null)
{
return(null);
}
string[] formats = null;
Dictionary <string, string[]> categories = new Dictionary <string, string[]>();
foreach (JProperty property in obj.Properties())
{
if (property.Name == "Formats")
{
formats = property.First.ToObject <string[]>();
}
else
{
categories.Add(property.Name, property.First.ToObject <string[]>());
}
}
return(new InsultDataSource(formats, categories, _variables));
}
public T GetValue <T>(string path)
{
Log.Data($"Reading JSON data at '{path}'.");
var val = JSONSerialization.DeserializeFile <T>(GetPath() + path);
return(val);
}
public void OnMessageReceived(string message)
{
Console.WriteLine("Received message from server: " + message);
if (JSONSerialization.TryParseJson(message, out GameState gameState))
{
Console.WriteLine("Received game state");
_gameForm.OnGameState(gameState);
// pass new game state to game form
}
else if (JSONSerialization.TryParseJson(message, out PlayerList players))
{
Console.WriteLine("Received player list");
// pass new player list to main form
if (players.playernames[0] == playerName)
{
_mainForm.ShowStartButton();
}
else
{
_mainForm.HideStartButton();
}
}
else if (message == StringLiterals.StartGame)
{
StartGame();
}
else if (message == StringLiterals.EndGame)
{
EndGame();
}
_mainForm.OnMessageReceived(message);
}
private void ChatCharacters_ChildAdded(object sender, ChildChangedEventArgs e)
{
var parent = e.Snapshot.Key;
if (!_chatCharacterDataDict.ContainsKey(parent))
{
_chatCharacterDataDict.Add(parent, new List <ChatCharacterData>());
}
var data = JSONSerialization <ChatCharacterData> .CreateDictionaryFromJSON(e.Snapshot.GetRawJsonValue());
foreach (var character in data)
{
character.Value.Key = character.Key;
_chatCharacterDataDict[parent].Add(character.Value);
}
foreach (var character in _chatCharacterDataDict[parent])
{
_databaseRef.Child(DB_NODE_CHARACTERS).Child(character.CharacterId).GetValueAsync().ContinueWith(innerTask =>
{
character.Data = JSONSerialization <CharacterData> .CreateFromJSON(innerTask.Result.GetRawJsonValue());
});
}
}
public void JsonTest()
{
var jsonSer = new JSONSerialization <Tank>();
jsonSer.Serialize(bat, pathJson);
var bat2 = jsonSer.Deserialize(pathJson);
CollectionAssert.AreEqual(bat.tanks, bat.tanks);
}
public void SaveRecord(RecordData data)
{
data.CreatedUTC = DateTime.UtcNow.ToShortDateString();
var json = JSONSerialization <RecordData> .CreateFromObject(data);
_databaseRef.Child(DB_NODE_RECORDS).Child(data.ChatRoomId).Push().SetRawJsonValueAsync(json).ContinueWith(task =>
{
});
}
private void jsonButton_Click(object sender, RoutedEventArgs e)
{
String actorPath = Environment.CurrentDirectory.ToString() + "\\Serialization\\JSON\\Actors.json";
String employeePath = Environment.CurrentDirectory.ToString() + "\\Serialization\\JSON\\Employees.json";
String scenePath = Environment.CurrentDirectory.ToString() + "\\Serialization\\JSON\\Scenes.json";
String filmPath = Environment.CurrentDirectory.ToString() + "\\Serialization\\JSON\\Films.json";
JSONSerialization serialization = new JSONSerialization();
SerializeData(serialization, actorPath, employeePath, scenePath, filmPath);
}
private void Load()
{
_users = JSONSerialization.DeserializeFile <List <ulong> > (_filePath);
if (_users == null)
{
_users = new List <ulong> {
0
};
Save();
}
}
public static bool IsDefault(Type pluginType) // This might fit better in the Plugin class.
{
var list = JSONSerialization.DeserializeFile <List <string> >(DefaultPluginsPath);
if (list == null)
{
list = new List <string>(_standardPlugins.Select(x => Plugin.GetFullName(x)));
JSONSerialization.SerializeObject(list, DefaultPluginsPath);
}
return(list.Contains(Plugin.GetFullName(pluginType)));
}
private void actionOnValidAuthentication(string restResult)
{
JSONSerialization jsonSerialization = new JSONSerialization();
var deserializeUser = jsonSerialization.DeserializeFromString <User>(restResult.ToString());
Program.CurrentUser = deserializeUser;
Main frmclientMain = new Main();
this.Visible = false;
frmclientMain.ShowDialog();
Close();
}
public async Task <PublishDeltaResult> PublishProductDeltas(IEnumerable <Product> products, IEnumerable <DeletedProductSku> deletedProducts, IEnumerable <AccountPrice> accountPrices, IEnumerable <DeletedAccountPrice> deletedAccountPrices, string accessKey)
{
var deltas = new List <ProcessedProductDelta>();
var publishDeltaResult = new PublishDeltaResult();
var endpoint = RegionEndpoints.GetRegionEndpoints(region);
var fullEndpoint = $"{endpoint.APIEndpoint}{deltaEndpointSuffix}";
try
{
deltas = ConversionManager.ProcessProductDeltas(products, deletedProducts, accountPrices, deletedAccountPrices, accessKey);
}
catch (Exception e)
{
return(new PublishDeltaResult
{
Success = false,
Errors = new List <PublishDeltaError> {
new PublishDeltaError {
Error = e.Message,
Skus = products.Count() > 0 ? products.Select(prod => prod.Sku) : null,
DeletedSkus = deletedProducts.Count() > 0 ? deletedProducts.Select(deletedProd => deletedProd.Sku) : null,
AccountPrices = accountPrices,
DeletedAccountPrices = deletedAccountPrices
}
}
});
}
foreach (var delta in deltas)
{
try
{
var json = JSONSerialization.SerializeToJSON(delta);
var deltaResult = await HttpCalls.Post <DeltaResult>(json, fullEndpoint);
publishDeltaResult.Tokens.Add(deltaResult.Token);
}
catch (Exception e)
{
publishDeltaResult.Errors.Add(new PublishDeltaError {
Error = e.Message,
Skus = products.Count() > 0 ? products.Select(prod => prod.Sku) : null,
DeletedSkus = deletedProducts.Count() > 0 ? deletedProducts.Select(deletedProd => deletedProd.Sku) : null,
AccountPrices = accountPrices,
DeletedAccountPrices = deletedAccountPrices
});
}
}
publishDeltaResult.Success = publishDeltaResult.Errors.Count == 0;
return(publishDeltaResult);
}
public T[] GetAllValues <T>(string path)
{
string directoryPath = GetPath() + path.Substring(0, path.LastIndexOf('/'));
string prefix = path.Substring(path.LastIndexOf("/") + 1);
string[] matches = Directory.GetFiles(directoryPath, $"{prefix}*");
T[] results = new T[matches.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = JSONSerialization.DeserializeFile <T>(matches[i]);
}
return(results);
}
public void JsonLoad()
{
foreach (GameObject item in allObjects)
{
Destroy(item);
}
allObjects.Clear();
ObjectInfoSaveLoad loadedClass = JSONSerialization.Load <ObjectInfoSaveLoad>();
SpawnWithData(loadedClass);
}
public bool RemovePlayer(string player)
{
if (player == PlayerHost)
{
PlayerHost = _pendingMoves.Keys.Where(x => x != PlayerHost).SingleOrDefault();
}
if (_pendingMoves.Remove(player) & _gameController.RemovePlayer(player))
{
var newPlayerList = new PlayerList(_pendingMoves.Keys.ToList());
WebSocketSingleton.GetInstance().SendMessageToAllPlayers(JSONSerialization.Serialize(newPlayerList));
return(true);
}
return(false);
}
public void CObjJSONDeserializationTest()
{
string fileName = "CDeserializationTest.json";
JSONSerialization <C> serializer = new JSONSerialization <C>(fileName, c);
serializer.Serialize();
JSONSerialization <C> tmp = new JSONSerialization <C>("CDeserializationTest.json", c);
C desResult = tmp.Deserialize();
Assert.AreEqual(desResult.Name, c.Name);
Assert.AreEqual(desResult.LastName, c.LastName);
Assert.AreEqual(desResult.Number, c.Number);
Assert.AreEqual(desResult.Date, c.Date);
}
public bool AddPlayer(string player)
{
if (_pendingMoves.Count == 0)
{
PlayerHost = player;
}
if (_pendingMoves.TryAdd(player, new PlayerMove()) &&
_gameController.AddPlayer(player))
{
var newPlayerList = new PlayerList(_pendingMoves.Keys.ToList());
WebSocketSingleton.GetInstance().SendMessageToAllPlayers(JSONSerialization.Serialize(newPlayerList));
return(true);
}
return(false);
}
public void AObjJSONDeserializationTest()
{
string fileName = "ADeserializationTest.json";
JSONSerialization <A> serializer = new JSONSerialization <A>(fileName, a);
serializer.Serialize();
JSONSerialization <A> tmp = new JSONSerialization <A>("ADeserializationTest.json", a);
A desResult = tmp.Deserialize();
Assert.AreEqual(desResult.Name, a.Name);
Assert.AreEqual(desResult.LastName, a.LastName);
Assert.AreEqual(desResult.Number, a.Number);
Assert.AreEqual(desResult.Date, a.Date);
}
public void BObjJSONDeserializationTest()
{
string fileName = "BDeserializationTest.json";
JSONSerialization <B> serializer = new JSONSerialization <B>(fileName, b);
serializer.Serialize();
JSONSerialization <B> tmp = new JSONSerialization <B>("BDeserializationTest.json", b);
B desResult = tmp.Deserialize();
Assert.AreEqual(desResult.Name, b.Name);
Assert.AreEqual(desResult.LastName, b.LastName);
Assert.AreEqual(desResult.Number, b.Number);
Assert.AreEqual(desResult.Date, b.Date);
}
private void createNewUserData(IGraphResult result)
{
Client.UserData = new User();
var userData = JSONSerialization <User> .CreateFromJSON(result.RawResult);
Client.UserData = userData;
Client.UserData.Token = AccessToken.CurrentAccessToken.TokenString;
Client.UserData.ChatCount = 0;
Client.UserData.ActiveChats = new Dictionary <string, string>();
Client.UserData.Invites = new Dictionary <string, string>();
DatabaseService.Instance.CreateUserDataEvent += handleCreateUserDataEvent;
DatabaseService.Instance.CreateNewUser(Client.UserData);
}
public void DeserializeCTest()
{
A a1 = new A("A", 1.1f, new DateTime(2019, 12, 1), null);
B b1 = new B("B", 3.65f, new DateTime(2019, 10, 1), null);
C c1 = new C("C", 5.37f, new DateTime(2020, 1, 2), null);
a1.ObjectB = b1;
b1.ObjectC = c1;
c1.ObjectA = a1;
JSONSerialization <C> json = new JSONSerialization <C>("ObiektC.json", c1);
C c2 = json.deserialize();
Assert.AreEqual(c1.Name, c2.Name);
Assert.AreEqual(c1.Number, c2.Number);
Assert.AreEqual(c1.Date, c2.Date);
Assert.AreEqual(c1.ObjectA.Name, c2.ObjectA.Name);
}
public void GetAvailableScenes()
{
_databaseRef.Child(DB_NODE_SCENES).OrderByKey().GetValueAsync().ContinueWith(task =>
{
if (task.IsCompleted)
{
var data = JSONSerialization <SceneData> .CreateDictionaryFromJSON(task.Result.GetRawJsonValue());
if (GetScenesEvent != null)
{
GetScenesEvent.Invoke(task.IsCompleted, data);
}
}
else if (task.IsFaulted)
{
}
});
}
public void GetUserInviteChats(string userId)
{
_databaseRef.Child(DB_NODE_USERS).Child(userId).Child("InviteChats").GetValueAsync().ContinueWith(task =>
{
if (task.IsCompleted)
{
var data = JSONSerialization <Dictionary <string, string> > .CreateFromJSON(task.Result.GetRawJsonValue());
if (GetInviteChatEvent != null)
{
GetInviteChatEvent.Invoke(true, data);
}
}
else if (task.IsFaulted)
{
}
});
}
public void OnTimedUpdate(object source, ElapsedEventArgs e)
{
if (_gameController.IsGameEnd())
{
OnGameEnd();
return;
}
var newGameState = _gameController.UpdateGameState(_pendingMoves);
// Clear pending actions
foreach (var player in _pendingMoves.Keys.ToList())
{
_pendingMoves[player] = new PlayerMove(); //Enums.PlayerAction.None;
}
// Send new game state to all players.
WebSocketSingleton.GetInstance().SendMessageToAllPlayers(JSONSerialization.Serialize(newGameState));
}
public void GetSceneCharacters(int sceneId)
{
_databaseRef.Child(DB_NODE_CHARACTERS).GetValueAsync().ContinueWith(task =>
{
if (task.IsCompleted)
{
var data = JSONSerialization <CharacterData> .CreateDictionaryFromJSON(task.Result.GetRawJsonValue());
if (GetCharactersEvent != null)
{
GetCharactersEvent.Invoke(task.IsCompleted, data);
}
}
else if (task.IsFaulted)
{
}
});
}
public void JsonSave()
{
for (int i = 0; i < allObjects.Count; i++)
{
Transform current = allObjects[i].transform;
ObjectInfo info = new ObjectInfo();
info.SetPosition(current.position);
info.SetRotation(current.eulerAngles);
info.SetShapeId(int.Parse(current.name));
info.SetColor(current.GetComponent <MeshRenderer>().material.color);
info.SetVelocity(current.GetComponent <Rigidbody>().velocity);
info.SetAngularVelocity(current.GetComponent <Rigidbody>().angularVelocity);
objSaveLoad.AddInfo(info);
}
JSONSerialization.Save(objSaveLoad);
}
public async Task <PublishFeedResult> PublishUserFeed(IEnumerable <User> users)
{
try
{
var userFeed = ConversionManager.ProcessUsers(users);
var feedJSON = JSONSerialization.SerializeToJSON(userFeed);
var endpoint = RegionEndpoints.GetRegionEndpoints(region);
await UploadToSTFPAsync(feedJSON, endpoint.SFTPEndpoint);
return(new PublishFeedResult {
Success = true, Token = ""
});
}
catch (Exception e)
{
return(new PublishFeedResult {
Success = false, Error = e.Message
});
}
}
private async Task <QueryTokensResult> CallTokenStatus(IEnumerable <string> tokens)
{
var queryResult = new QueryTokensResult();
var tokenFeed = new TokenFeed {
AppKey = _accessKey, Tokens = tokens.ToArray()
};
var json = JSONSerialization.SerializeToJSON(tokenFeed);
var resonse = await HttpCalls.Post <JArray>(json, _fullEndpoint);
if (resonse != null)
{
foreach (var jsonObject in resonse)
{
var token = JsonConvert.DeserializeObject <TokenStatus>(jsonObject.ToString());
queryResult.TokenStatuses.Add(token);
}
}
return(queryResult);
}
public async Task <PublishFeedResult> PublishProductFeed(IEnumerable <Product> products, IEnumerable <AccountPrice> accountPrices)
{
try
{
var productFeed = ConversionManager.ProcessProductFeed(products, accountPrices);
var feedJSON = JSONSerialization.SerializeToJSON(productFeed);
var endpoint = RegionEndpoints.GetRegionEndpoints(region);
await UploadToSTFPAsync(feedJSON, endpoint.SFTPEndpoint);
return(new PublishFeedResult {
Success = true, Token = ""
});
}
catch (Exception e)
{
return(new PublishFeedResult {
Success = false, Error = e.Message, StackTrace = e.StackTrace
});
}
}
private static void CacheFullTanslationTable()
{
string[] files = Directory.GetFiles(LocalizationsDirectory);
foreach (string file in files)
{
var(culture, identifier) = DeformatName(Path.GetFileNameWithoutExtension(file));
Dictionary <string, string> dict = JSONSerialization.DeserializeFile <Dictionary <string, string> >(file);
if (!_translationTable.ContainsKey(culture))
{
_translationTable.Add(culture, new Dictionary <string, Dictionary <string, string> >());
}
if (!_translationTable[culture].ContainsKey(identifier))
{
_translationTable[culture].Add(identifier, null);
}
_translationTable[culture][identifier] = dict;
}
}
public void BObjJSONSerializationTest()
{
string fileName = "BSerializationTest.json";
JSONSerialization <B> serializer = new JSONSerialization <B>(fileName, b);
serializer.Serialize();
string serializedContent = File.ReadAllText(fileName);
JObject targetJObject = JsonConvert.DeserializeObject <JObject>(@"{
""$id"": ""1"",
""$type"": ""Zad2Serializer.ObjectModel.B, Zad2Serializer"",
""Name"": ""Sebastian"",
""LastName"": ""Kujawski"",
""Number"": 9669,
""Date"": ""2019-10-01T00:00:00"",
""ObjC"": {
""$id"": ""2"",
""$type"": ""Zad2Serializer.ObjectModel.C, Zad2Serializer"",
""Name"": ""Michał"",
""LastName"": ""Kowalski"",
""Number"": 5321,
""Date"": ""2020-01-02T00:00:00"",
""ObjA"": {
""$id"": ""3"",
""$type"": ""Zad2Serializer.ObjectModel.A, Zad2Serializer"",
""Name"": ""Dominik"",
""LastName"": ""Karski"",
""Number"": 4124,
""Date"": ""2019-12-01T00:00:00"",
""ObjB"": {
""$ref"": ""1""
}
}
}
}");
JObject resultObject = JsonConvert.DeserializeObject <JObject>(serializedContent);
Assert.IsTrue(JToken.DeepEquals(resultObject, targetJObject));
}
