Invert directives and use ZeroDepJson by default

kirre-bylund · kirre-bylund · commit 58cba44989b2 · 2023-04-28T10:27:52.000+02:00
diff --git a/Runtime/Client/GetRequests.cs b/Runtime/Client/GetRequests.cs
@@ -1,5 +1,5 @@
 ﻿using System.Collections.Generic;
-#if LOOTLOCKER_USE_ZERODEPJSON
+#if !LOOTLOCKER_USE_NEWTONSOFTJSON
 using LLlibs.ZeroDepJson;
 #endif
 
@@ -8,7 +8,7 @@ namespace LootLocker.Requests
     public class LootLockerGetRequest
     {
 
-#if LOOTLOCKER_USE_ZERODEPJSON
+#if !LOOTLOCKER_USE_NEWTONSOFTJSON
         [Json(IgnoreWhenSerializing = true, IgnoreWhenDeserializing = true)]
         public List<string> getRequests = new List<string>();
 #else
diff --git a/Runtime/Client/LootLockerBaseServerAPI.cs b/Runtime/Client/LootLockerBaseServerAPI.cs
@@ -5,11 +5,11 @@
 using System;
 using System.Text;
 using System.Net;
-#if LOOTLOCKER_USE_ZERODEPJSON
-using LLlibs.ZeroDepJson;
-#elif LOOTLOCKER_USE_NEWTONSOFTJSON
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+#else
+using LLlibs.ZeroDepJson;
 #endif
 using LootLocker.Requests;
 
@@ -369,36 +369,35 @@ public ObfuscationDetails(string key, char replacementChar = '*', int visibleCha
         };
 
         private static string ObfuscateJsonStringForLogging(string json)
-        {
-#if LOOTLOCKER_USE_ZERODEPJSON
-            if (string.IsNullOrEmpty(json) || json.Equals("{}"))
+        {
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
+            if (string.IsNullOrEmpty(json))
             {
                 return json;
             }
-
-            Dictionary<string, object> jsonObject = null;
+            
+            JObject jsonObject;
             try
             {
-                jsonObject = Json.Deserialize(json) as Dictionary<string, object>;
+                jsonObject = JObject.Parse(json);
             }
-            catch (JsonException)
+            catch (JsonReaderException)
             {
                 return json;
             }
-
-            if (jsonObject != null && jsonObject.Count > 0)
+            ;
+            if (jsonObject.HasValues)
             {
                 foreach (ObfuscationDetails obfuscationInfo in FieldsToObfuscate)
                 {
                     string valueToObfuscate;
                     try
                     {
-                        if (!jsonObject.ContainsKey(obfuscationInfo.key))
-                        {
+                        JToken jsonValue;
+                        jsonObject.TryGetValue(obfuscationInfo.key, StringComparison.Ordinal, out jsonValue);
+                        if (jsonValue == null || (jsonValue.Type != JTokenType.String && jsonValue.Type != JTokenType.Integer))
                             continue;
-                        }
-
-                        valueToObfuscate = Json.Serialize(jsonObject[obfuscationInfo.key]);
+                        valueToObfuscate = jsonValue.ToString();
                     }
                     catch (KeyNotFoundException)
                     {
@@ -437,34 +436,36 @@ private static string ObfuscateJsonStringForLogging(string json)
             }
 
             return LootLockerJson.SerializeObject(jsonObject);
-#else
-            if (string.IsNullOrEmpty(json))
+            
+#else //LOOTLOCKER_USE_NEWTONSOFTJSON
+            if (string.IsNullOrEmpty(json) || json.Equals("{}"))
             {
                 return json;
             }
-            
-            JObject jsonObject;
+
+            Dictionary<string, object> jsonObject = null;
             try
             {
-                jsonObject = JObject.Parse(json);
+                jsonObject = Json.Deserialize(json) as Dictionary<string, object>;
             }
-            catch (JsonReaderException)
+            catch (JsonException)
             {
                 return json;
             }
-            ;
-            if (jsonObject.HasValues)
+
+            if (jsonObject != null && jsonObject.Count > 0)
             {
                 foreach (ObfuscationDetails obfuscationInfo in FieldsToObfuscate)
                 {
                     string valueToObfuscate;
                     try
                     {
-                        JToken jsonValue;
-                        jsonObject.TryGetValue(obfuscationInfo.key, StringComparison.Ordinal, out jsonValue);
-                        if (jsonValue == null || (jsonValue.Type != JTokenType.String && jsonValue.Type != JTokenType.Integer))
+                        if (!jsonObject.ContainsKey(obfuscationInfo.key))
+                        {
                             continue;
-                        valueToObfuscate = jsonValue.ToString();
+                        }
+
+                        valueToObfuscate = Json.Serialize(jsonObject[obfuscationInfo.key]);
                     }
                     catch (KeyNotFoundException)
                     {
@@ -503,7 +504,7 @@ private static string ObfuscateJsonStringForLogging(string json)
             }
 
             return LootLockerJson.SerializeObject(jsonObject);
-#endif
+#endif //LOOTLOCKER_USE_NEWTONSOFTJSON
         }
 
         string BuildURL(string endpoint, Dictionary<string, string> queryParams = null)
diff --git a/Runtime/Client/LootLockerServerRequest.cs b/Runtime/Client/LootLockerServerRequest.cs
@@ -2,11 +2,11 @@
 using UnityEngine;
 using System;
 using LootLocker.LootLockerEnums;
-#if LOOTLOCKER_USE_ZERODEPJSON
-using LLlibs.ZeroDepJson;
-#elif LOOTLOCKER_USE_NEWTONSOFTJSON
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
+#else
+using LLlibs.ZeroDepJson;
 #endif
 #if UNITY_EDITOR
 using UnityEditor;
@@ -18,61 +18,61 @@ namespace LootLocker
 
     public static class LootLockerJsonSettings
     {
-#if LOOTLOCKER_USE_ZERODEPJSON
-        public static readonly JsonOptions Default = new JsonOptions(JsonSerializationOptions.Default & ~JsonSerializationOptions.SkipGetOnly);
-#else //LOOTLOCKER_USE_ZERODEPJSON
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
         public static readonly JsonSerializerSettings Default = new JsonSerializerSettings
         {
             ContractResolver = new DefaultContractResolver { NamingStrategy = new SnakeCaseNamingStrategy() },
             Formatting = Formatting.None
         };
+#else
+        public static readonly JsonOptions Default = new JsonOptions(JsonSerializationOptions.Default & ~JsonSerializationOptions.SkipGetOnly);
 #endif
     }
 
     public static class LootLockerJson
-    {
-#if LOOTLOCKER_USE_ZERODEPJSON
+    {
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
         public static string SerializeObject(object obj)
         {
             return SerializeObject(obj, LootLockerJsonSettings.Default);
         }
 
-        public static string SerializeObject(object obj, JsonOptions options)
+        public static string SerializeObject(object obj, JsonSerializerSettings settings)
         {
-            return Json.Serialize(obj, options ?? LootLockerJsonSettings.Default);
+            return JsonConvert.SerializeObject(obj, settings ?? LootLockerJsonSettings.Default);
         }
 
         public static T DeserializeObject<T>(string json)
         {
             return DeserializeObject<T>(json, LootLockerJsonSettings.Default);
         }
 
-        public static T DeserializeObject<T>(string json, JsonOptions options)
+
+        public static T DeserializeObject<T>(string json, JsonSerializerSettings settings)
         {
-            return Json.Deserialize<T>(json, options ?? LootLockerJsonSettings.Default);
+            return JsonConvert.DeserializeObject<T>(json, settings ?? LootLockerJsonSettings.Default);
         }
-#else //LOOTLOCKER_USE_ZERODEPJSON
+#else //LOOTLOCKER_USE_NEWTONSOFTJSON
         public static string SerializeObject(object obj)
         {
             return SerializeObject(obj, LootLockerJsonSettings.Default);
         }
 
-        public static string SerializeObject(object obj, JsonSerializerSettings settings)
+        public static string SerializeObject(object obj, JsonOptions options)
         {
-            return JsonConvert.SerializeObject(obj, settings ?? LootLockerJsonSettings.Default);
+            return Json.Serialize(obj, options ?? LootLockerJsonSettings.Default);
         }
 
         public static T DeserializeObject<T>(string json)
         {
             return DeserializeObject<T>(json, LootLockerJsonSettings.Default);
         }
 
-
-        public static T DeserializeObject<T>(string json, JsonSerializerSettings settings)
+        public static T DeserializeObject<T>(string json, JsonOptions options)
         {
-            return JsonConvert.DeserializeObject<T>(json, settings ?? LootLockerJsonSettings.Default);
+            return Json.Deserialize<T>(json, options ?? LootLockerJsonSettings.Default);
         }
-#endif
+#endif //LOOTLOCKER_USE_NEWTONSOFTJSON
     }
 
     [Serializable]
@@ -128,10 +128,10 @@ public class LootLockerResponse
         public string EventId { get; set; }
 
         public static void Deserialize<T>(Action<T> onComplete, LootLockerResponse serverResponse,
-#if LOOTLOCKER_USE_ZERODEPJSON
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
+            JsonSerializerSettings options = null
+#else //LOOTLOCKER_USE_NEWTONSOFTJSON
             JsonOptions options = null
-#else //LOOTLOCKER_USE_ZERODEPJSON
-      JsonSerializerSettings options = null
 #endif
             )
             where T : LootLockerResponse, new()
@@ -140,10 +140,10 @@ public static void Deserialize<T>(Action<T> onComplete, LootLockerResponse serve
         }
 
         public static T Deserialize<T>(LootLockerResponse serverResponse,
-#if LOOTLOCKER_USE_ZERODEPJSON
-            JsonOptions options = null
-#else //LOOTLOCKER_USE_ZERODEPJSON
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
             JsonSerializerSettings options = null
+#else //LOOTLOCKER_USE_NEWTONSOFTJSON
+            JsonOptions options = null
 #endif
             )
             where T : LootLockerResponse, new() 
diff --git a/Runtime/Game/Requests/PlayerRequest.cs b/Runtime/Game/Requests/PlayerRequest.cs
@@ -1,9 +1,9 @@
 using System;
-using LootLocker.Requests;
-#if LOOTLOCKER_USE_ZERODEPJSON
-using LLlibs.ZeroDepJson;
-#elif LOOTLOCKER_USE_NEWTONSOFTJSON
+using LootLocker.Requests;
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
 using Newtonsoft.Json;
+#else
+using LLlibs.ZeroDepJson;
 #endif
 
 namespace LootLocker.Requests
@@ -208,10 +208,10 @@ public class LootLockerPlayerFile : LootLockerResponse
         public int size { get; set; }
         public string purpose { get; set; }
 
-#if LOOTLOCKER_USE_ZERODEPJSON
-        [Json(Name = "public")]
-#else
+#if LOOTLOCKER_USE_NEWTONSOFTJSON
         [JsonProperty("public")]
+#else
+        [Json(Name = "public")]
 #endif
         public bool is_public { get; set; }
         public string url { get; set; }

Original file line number	Diff line number	Diff line change
`@@ -5,11 +5,11 @@`
`5`	`5`	`using System;`
`6`	`6`	`using System.Text;`
`7`	`7`	`using System.Net;`
`8`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
`9`		`-using LLlibs.ZeroDepJson;`
`10`		`-#elif LOOTLOCKER_USE_NEWTONSOFTJSON`
	`8`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
`11`	`9`	`using Newtonsoft.Json;`
`12`	`10`	`using Newtonsoft.Json.Linq;`
	`11`	`+#else`
	`12`	`+using LLlibs.ZeroDepJson;`
`13`	`13`	`#endif`
`14`	`14`	`using LootLocker.Requests;`
`15`	`15`
`@@ -369,36 +369,35 @@ public ObfuscationDetails(string key, char replacementChar = '*', int visibleCha`
`369`	`369`	`};`
`370`	`370`
`371`	`371`	`private static string ObfuscateJsonStringForLogging(string json)`
`372`		`- {`
`373`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
`374`		`- if (string.IsNullOrEmpty(json) \|\| json.Equals("{}"))`
	`372`	`+ {`
	`373`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
	`374`	`+ if (string.IsNullOrEmpty(json))`
`375`	`375`	`{`
`376`	`376`	`return json;`
`377`	`377`	`}`
`378`		`-`
`379`		`- Dictionary<string, object> jsonObject = null;`
	`378`	`+`
	`379`	`+ JObject jsonObject;`
`380`	`380`	`try`
`381`	`381`	`{`
`382`		`- jsonObject = Json.Deserialize(json) as Dictionary<string, object>;`
	`382`	`+ jsonObject = JObject.Parse(json);`
`383`	`383`	`}`
`384`		`- catch (JsonException)`
	`384`	`+ catch (JsonReaderException)`
`385`	`385`	`{`
`386`	`386`	`return json;`
`387`	`387`	`}`
`388`		`-`
`389`		`- if (jsonObject != null && jsonObject.Count > 0)`
	`388`	`+ ;`
	`389`	`+ if (jsonObject.HasValues)`
`390`	`390`	`{`
`391`	`391`	`foreach (ObfuscationDetails obfuscationInfo in FieldsToObfuscate)`
`392`	`392`	`{`
`393`	`393`	`string valueToObfuscate;`
`394`	`394`	`try`
`395`	`395`	`{`
`396`		`- if (!jsonObject.ContainsKey(obfuscationInfo.key))`
`397`		`- {`
	`396`	`+ JToken jsonValue;`
	`397`	`+ jsonObject.TryGetValue(obfuscationInfo.key, StringComparison.Ordinal, out jsonValue);`
	`398`	`+ if (jsonValue == null \|\| (jsonValue.Type != JTokenType.String && jsonValue.Type != JTokenType.Integer))`
`398`	`399`	`continue;`
`399`		`- }`
`400`		`-`
`401`		`- valueToObfuscate = Json.Serialize(jsonObject[obfuscationInfo.key]);`
	`400`	`+ valueToObfuscate = jsonValue.ToString();`
`402`	`401`	`}`
`403`	`402`	`catch (KeyNotFoundException)`
`404`	`403`	`{`
`@@ -437,34 +436,36 @@ private static string ObfuscateJsonStringForLogging(string json)`
`437`	`436`	`}`
`438`	`437`
`439`	`438`	`return LootLockerJson.SerializeObject(jsonObject);`
`440`		`-#else`
`441`		`- if (string.IsNullOrEmpty(json))`
	`439`	`+`
	`440`	`+#else //LOOTLOCKER_USE_NEWTONSOFTJSON`
	`441`	`+ if (string.IsNullOrEmpty(json) \|\| json.Equals("{}"))`
`442`	`442`	`{`
`443`	`443`	`return json;`
`444`	`444`	`}`
`445`		`-`
`446`		`- JObject jsonObject;`
	`445`	`+`
	`446`	`+ Dictionary<string, object> jsonObject = null;`
`447`	`447`	`try`
`448`	`448`	`{`
`449`		`- jsonObject = JObject.Parse(json);`
	`449`	`+ jsonObject = Json.Deserialize(json) as Dictionary<string, object>;`
`450`	`450`	`}`
`451`		`- catch (JsonReaderException)`
	`451`	`+ catch (JsonException)`
`452`	`452`	`{`
`453`	`453`	`return json;`
`454`	`454`	`}`
`455`		`- ;`
`456`		`- if (jsonObject.HasValues)`
	`455`	`+`
	`456`	`+ if (jsonObject != null && jsonObject.Count > 0)`
`457`	`457`	`{`
`458`	`458`	`foreach (ObfuscationDetails obfuscationInfo in FieldsToObfuscate)`
`459`	`459`	`{`
`460`	`460`	`string valueToObfuscate;`
`461`	`461`	`try`
`462`	`462`	`{`
`463`		`- JToken jsonValue;`
`464`		`- jsonObject.TryGetValue(obfuscationInfo.key, StringComparison.Ordinal, out jsonValue);`
`465`		`- if (jsonValue == null \|\| (jsonValue.Type != JTokenType.String && jsonValue.Type != JTokenType.Integer))`
	`463`	`+ if (!jsonObject.ContainsKey(obfuscationInfo.key))`
	`464`	`+ {`
`466`	`465`	`continue;`
`467`		`- valueToObfuscate = jsonValue.ToString();`
	`466`	`+ }`
	`467`	`+`
	`468`	`+ valueToObfuscate = Json.Serialize(jsonObject[obfuscationInfo.key]);`
`468`	`469`	`}`
`469`	`470`	`catch (KeyNotFoundException)`
`470`	`471`	`{`
`@@ -503,7 +504,7 @@ private static string ObfuscateJsonStringForLogging(string json)`
`503`	`504`	`}`
`504`	`505`
`505`	`506`	`return LootLockerJson.SerializeObject(jsonObject);`
`506`		`-#endif`
	`507`	`+#endif //LOOTLOCKER_USE_NEWTONSOFTJSON`
`507`	`508`	`}`
`508`	`509`
`509`	`510`	`string BuildURL(string endpoint, Dictionary<string, string> queryParams = null)`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,11 @@`
`2`	`2`	`using UnityEngine;`
`3`	`3`	`using System;`
`4`	`4`	`using LootLocker.LootLockerEnums;`
`5`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
`6`		`-using LLlibs.ZeroDepJson;`
`7`		`-#elif LOOTLOCKER_USE_NEWTONSOFTJSON`
	`5`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
`8`	`6`	`using Newtonsoft.Json;`
`9`	`7`	`using Newtonsoft.Json.Serialization;`
	`8`	`+#else`
	`9`	`+using LLlibs.ZeroDepJson;`
`10`	`10`	`#endif`
`11`	`11`	`#if UNITY_EDITOR`
`12`	`12`	`using UnityEditor;`
`@@ -18,61 +18,61 @@ namespace LootLocker`
`18`	`18`
`19`	`19`	`public static class LootLockerJsonSettings`
`20`	`20`	`{`
`21`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
`22`		`- public static readonly JsonOptions Default = new JsonOptions(JsonSerializationOptions.Default & ~JsonSerializationOptions.SkipGetOnly);`
`23`		`-#else //LOOTLOCKER_USE_ZERODEPJSON`
	`21`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
`24`	`22`	`public static readonly JsonSerializerSettings Default = new JsonSerializerSettings`
`25`	`23`	`{`
`26`	`24`	`ContractResolver = new DefaultContractResolver { NamingStrategy = new SnakeCaseNamingStrategy() },`
`27`	`25`	`Formatting = Formatting.None`
`28`	`26`	`};`
	`27`	`+#else`
	`28`	`+ public static readonly JsonOptions Default = new JsonOptions(JsonSerializationOptions.Default & ~JsonSerializationOptions.SkipGetOnly);`
`29`	`29`	`#endif`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public static class LootLockerJson`
`33`		`- {`
`34`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
	`33`	`+ {`
	`34`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
`35`	`35`	`public static string SerializeObject(object obj)`
`36`	`36`	`{`
`37`	`37`	`return SerializeObject(obj, LootLockerJsonSettings.Default);`
`38`	`38`	`}`
`39`	`39`
`40`		`- public static string SerializeObject(object obj, JsonOptions options)`
	`40`	`+ public static string SerializeObject(object obj, JsonSerializerSettings settings)`
`41`	`41`	`{`
`42`		`- return Json.Serialize(obj, options ?? LootLockerJsonSettings.Default);`
	`42`	`+ return JsonConvert.SerializeObject(obj, settings ?? LootLockerJsonSettings.Default);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`public static T DeserializeObject<T>(string json)`
`46`	`46`	`{`
`47`	`47`	`return DeserializeObject<T>(json, LootLockerJsonSettings.Default);`
`48`	`48`	`}`
`49`	`49`
`50`		`- public static T DeserializeObject<T>(string json, JsonOptions options)`
	`50`	`+`
	`51`	`+ public static T DeserializeObject<T>(string json, JsonSerializerSettings settings)`
`51`	`52`	`{`
`52`		`- return Json.Deserialize<T>(json, options ?? LootLockerJsonSettings.Default);`
	`53`	`+ return JsonConvert.DeserializeObject<T>(json, settings ?? LootLockerJsonSettings.Default);`
`53`	`54`	`}`
`54`		`-#else //LOOTLOCKER_USE_ZERODEPJSON`
	`55`	`+#else //LOOTLOCKER_USE_NEWTONSOFTJSON`
`55`	`56`	`public static string SerializeObject(object obj)`
`56`	`57`	`{`
`57`	`58`	`return SerializeObject(obj, LootLockerJsonSettings.Default);`
`58`	`59`	`}`
`59`	`60`
`60`		`- public static string SerializeObject(object obj, JsonSerializerSettings settings)`
	`61`	`+ public static string SerializeObject(object obj, JsonOptions options)`
`61`	`62`	`{`
`62`		`- return JsonConvert.SerializeObject(obj, settings ?? LootLockerJsonSettings.Default);`
	`63`	`+ return Json.Serialize(obj, options ?? LootLockerJsonSettings.Default);`
`63`	`64`	`}`
`64`	`65`
`65`	`66`	`public static T DeserializeObject<T>(string json)`
`66`	`67`	`{`
`67`	`68`	`return DeserializeObject<T>(json, LootLockerJsonSettings.Default);`
`68`	`69`	`}`
`69`	`70`
`70`		`-`
`71`		`- public static T DeserializeObject<T>(string json, JsonSerializerSettings settings)`
	`71`	`+ public static T DeserializeObject<T>(string json, JsonOptions options)`
`72`	`72`	`{`
`73`		`- return JsonConvert.DeserializeObject<T>(json, settings ?? LootLockerJsonSettings.Default);`
	`73`	`+ return Json.Deserialize<T>(json, options ?? LootLockerJsonSettings.Default);`
`74`	`74`	`}`
`75`		`-#endif`
	`75`	`+#endif //LOOTLOCKER_USE_NEWTONSOFTJSON`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`[Serializable]`
`@@ -128,10 +128,10 @@ public class LootLockerResponse`
`128`	`128`	`public string EventId { get; set; }`
`129`	`129`
`130`	`130`	`public static void Deserialize<T>(Action<T> onComplete, LootLockerResponse serverResponse,`
`131`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
	`131`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
	`132`	`+ JsonSerializerSettings options = null`
	`133`	`+#else //LOOTLOCKER_USE_NEWTONSOFTJSON`
`132`	`134`	`JsonOptions options = null`
`133`		`-#else //LOOTLOCKER_USE_ZERODEPJSON`
`134`		`- JsonSerializerSettings options = null`
`135`	`135`	`#endif`
`136`	`136`	`)`
`137`	`137`	`where T : LootLockerResponse, new()`
`@@ -140,10 +140,10 @@ public static void Deserialize<T>(Action<T> onComplete, LootLockerResponse serve`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`public static T Deserialize<T>(LootLockerResponse serverResponse,`
`143`		`-#if LOOTLOCKER_USE_ZERODEPJSON`
`144`		`- JsonOptions options = null`
`145`		`-#else //LOOTLOCKER_USE_ZERODEPJSON`
	`143`	`+#if LOOTLOCKER_USE_NEWTONSOFTJSON`
`146`	`144`	`JsonSerializerSettings options = null`
	`145`	`+#else //LOOTLOCKER_USE_NEWTONSOFTJSON`
	`146`	`+ JsonOptions options = null`
`147`	`147`	`#endif`
`148`	`148`	`)`
`149`	`149`	`where T : LootLockerResponse, new()`