public void IListClear()
{
var p = new JProperty("TestProperty", null);
IList l = p;
AssertException.Throws<JsonException>(() => { l.Clear(); }, "Cannot add or remove items from OpenGamingLibrary.Json.Linq.JProperty.");
}
public void IListCount()
{
var p = new JProperty("TestProperty", null);
IList l = p;
Assert.Equal(1, l.Count);
}
public void NullValue()
{
var p = new JProperty("TestProperty", null);
Assert.NotNull(p.Value);
Assert.Equal(JTokenType.Null, p.Value.Type);
Assert.Equal(p, p.Value.Parent);
p.Value = null;
Assert.NotNull(p.Value);
Assert.Equal(JTokenType.Null, p.Value.Type);
Assert.Equal(p, p.Value.Parent);
}
public void ListChanged()
{
var p = new JProperty("TestProperty", null);
IBindingList l = p;
ListChangedType? listChangedType = null;
int? index = null;
l.ListChanged += (sender, args) =>
{
listChangedType = args.ListChangedType;
index = args.NewIndex;
};
p.Value = 1;
Assert.Equal(ListChangedType.ItemChanged, listChangedType.Value);
Assert.Equal(0, index.Value);
}
public void ReplaceJPropertyWithJPropertyWithSameName()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
var o = new JObject(p1, p2);
IList l = o;
Assert.Equal(p1, l[0]);
Assert.Equal(p2, l[1]);
JProperty p3 = new JProperty("Test1", "III");
p1.Replace(p3);
Assert.Equal(null, p1.Parent);
Assert.Equal(l, p3.Parent);
Assert.Equal(p3, l[0]);
Assert.Equal(p2, l[1]);
Assert.Equal(2, l.Count);
Assert.Equal(2, o.Properties().Count());
JProperty p4 = new JProperty("Test4", "IV");
p2.Replace(p4);
Assert.Equal(null, p2.Parent);
Assert.Equal(l, p4.Parent);
Assert.Equal(p3, l[0]);
Assert.Equal(p4, l[1]);
}
/// <summary>
/// To handle custom settings, we serialize using LaunchProfileData first and then walk the settings
/// to pick up other settings. Currently limited to boolean, integer, string and dictionary of string
/// </summary>
public static Dictionary <string, LaunchProfileData> DeserializeProfiles(JObject profilesObject)
{
var profiles = new Dictionary <string, LaunchProfileData>(StringComparer.Ordinal);
if (profilesObject == null)
{
return(profiles);
}
// We walk the profilesObject and serialize each subobject component as either a string, or a dictionary<string,string>
foreach (var profile in profilesObject)
{
// Name of profile is the key, value is it's contents. We have specific serializing of the data based on the
// JToken type
LaunchProfileData profileData = JsonConvert.DeserializeObject <LaunchProfileData>(profile.Value.ToString());
// Now pick up any custom properties. Handle string, int, boolean
Dictionary <string, object> customSettings = new Dictionary <string, object>(StringComparer.Ordinal);
foreach (var data in profile.Value.Children())
{
JProperty dataProperty = data as JProperty;
if (dataProperty == null)
{
continue;
}
if (!IsKnownProfileProperty(dataProperty.Name))
{
try
{
switch (dataProperty.Value.Type)
{
case JTokenType.Boolean:
{
bool value = bool.Parse(dataProperty.Value.ToString());
customSettings.Add(dataProperty.Name, value);
break;
}
case JTokenType.Integer:
{
int value = int.Parse(dataProperty.Value.ToString());
customSettings.Add(dataProperty.Name, value);
break;
}
case JTokenType.Object:
{
var value = JsonConvert.DeserializeObject <Dictionary <string, string> >(dataProperty.Value.ToString());
customSettings.Add(dataProperty.Name, value);
break;
}
case JTokenType.String:
{
customSettings.Add(dataProperty.Name, dataProperty.Value.ToString());
break;
}
default:
{
break;
}
}
}
catch
{
// TODO: should have message indicating the setting is being ignored. Fix as part of issue
// https://github.com/dotnet/roslyn-project-system/issues/424
}
}
}
// Only add custom settings if we actually picked some up
if (customSettings.Count > 0)
{
profileData.OtherSettings = customSettings;
}
profiles.Add(profile.Key, profileData);
}
return(profiles);
}
public void IListGenericAdd()
{
IList<JToken> t = new JProperty("error", new List<string> { "one", "two" });
AssertException.Throws<JsonException>(() => { t.Add(1); }, "OpenGamingLibrary.Json.Linq.JProperty cannot have multiple values.");
}
public void JPropertyDeepEquals()
{
JProperty p1 = new JProperty("TestProperty", null);
JProperty p2 = new JProperty("TestProperty", null);
Assert.Equal(true, JToken.DeepEquals(p1, p2));
}
public void IListSetItemInvalid()
{
AssertException.Throws<ArgumentException>(() =>
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
l[0] = new JValue(true);
}, @"Can not add OpenGamingLibrary.Json.Linq.JValue to OpenGamingLibrary.Json.Linq.JObject.");
}
public void IListRemoveAt()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
// won't do anything
l.RemoveAt(0);
l.Remove(p1);
Assert.Equal(1, l.Count);
l.Remove(p2);
Assert.Equal(0, l.Count);
}
public void IListAddBadToken()
{
AssertException.Throws<ArgumentException>(() =>
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
l.Add(new JValue("Bad!"));
}, "Can not add OpenGamingLibrary.Json.Linq.JValue to OpenGamingLibrary.Json.Linq.JObject.");
}
/// <summary>
/// Verifies the extension rule.
/// </summary>
/// <param name="context">The Interop service context</param>
/// <param name="info">out parameter to return violation information when rule does not pass</param>
/// <returns>true if rule passes; false otherwise</returns>
public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
bool?passed = null;
info = null;
ServiceStatus serviceStatus = ServiceStatus.GetInstance();
DataFactory dFactory = DataFactory.Instance();
var detail = new ExtensionRuleResultDetail(this.Name, serviceStatus.RootURL, HttpMethod.Post, string.Empty);
string updateUrl = serviceStatus.RootURL;
List <string> keyPropertyTypes = new List <string>()
{
"Edm.Int32", "Edm.Int16", "Edm.Int64", "Edm.Guid", "Edm.String"
};
List <string> norPropertyTypes = new List <string>()
{
"Edm.String"
};
List <EntityTypeElement> entityTypeElements = MetadataHelper.GetEntityTypes(serviceStatus.MetadataDocument, 1, keyPropertyTypes, null, NavigationRoughType.None).ToList();
if (null == entityTypeElements || 0 == entityTypeElements.Count)
{
detail.ErrorMessage = "To verify this rule it expects an entity type with Int32/Int64/Int16/Guid/String key property and a string type normal property, but there is no this entity type in metadata so can not verify this rule.";
info = new ExtensionRuleViolationInfo(new Uri(serviceStatus.RootURL), serviceStatus.ServiceDocument, detail);
return(passed);
}
EntityTypeElement entityType = null;
Dictionary <string, Dictionary <KeyValuePair <string, string>, List <string> > > entityTypeInfo = new Dictionary <string, Dictionary <KeyValuePair <string, string>, List <string> > >();
bool foundEntity = MetadataHelper.GetEntityTypesWithComplexProperty(serviceStatus.MetadataDocument, "Edm.String", out entityTypeInfo);
if (foundEntity)
{
foreach (var en in entityTypeElements)
{
if (entityTypeInfo.Keys.Contains(en.EntityTypeShortName) && !string.IsNullOrEmpty(en.EntitySetName))
{
entityType = en;
break;
}
}
}
else
{
detail.ErrorMessage = "To verify this rule it expects an entity type with complex type normal property, but there is no this entity type in metadata so can not verify this rule.";
info = new ExtensionRuleViolationInfo(new Uri(serviceStatus.RootURL), serviceStatus.ServiceDocument, detail);
return(passed);
}
if (entityType == null)
{
detail.ErrorMessage = "To verify this rule it expects an entity type with complex type normal property, but there is no this entity type in metadata so can not verify this rule.";
info = new ExtensionRuleViolationInfo(new Uri(serviceStatus.RootURL), serviceStatus.ServiceDocument, detail);
return(passed);
}
Dictionary <KeyValuePair <string, string>, List <string> > complexProps = entityTypeInfo[entityType.EntityTypeShortName];
KeyValuePair <KeyValuePair <string, string>, List <string> > complexPop = complexProps.First();
string complexPropName = complexPop.Key.Key;
string entitySetUrl = entityType.EntitySetName.MapEntitySetNameToEntitySetURL();
updateUrl = entitySetUrl;
string url = serviceStatus.RootURL.TrimEnd('/') + @"/" + entitySetUrl;
updateUrl = url;
var additionalInfos = new List <AdditionalInfo>();
JObject reqData = dFactory.ConstructInsertedEntityData(entityType.EntitySetName, entityType.EntityTypeShortName, null, out additionalInfos);
if (!dFactory.CheckOrAddTheMissingPropertyData(entityType.EntitySetName, complexPropName, ref reqData))
{
detail.ErrorMessage = "The property to update does not exist, and cannot be updated.";
info = new ExtensionRuleViolationInfo(new Uri(serviceStatus.RootURL), serviceStatus.ServiceDocument, detail);
return(passed);
}
string reqDataStr = reqData.ToString();
bool isMediaType = !string.IsNullOrEmpty(additionalInfos.Last().ODataMediaEtag);
var resp = WebHelper.CreateEntity(url, context.RequestHeaders, reqData, isMediaType, ref additionalInfos);
detail = new ExtensionRuleResultDetail(this.Name, url, HttpMethod.Post, string.Empty, resp, string.Empty, reqDataStr);
if (HttpStatusCode.Created == resp.StatusCode)
{
string entityId = additionalInfos.Last().EntityId;
updateUrl = entityId.TrimEnd('/') + "/" + complexPropName;
bool hasEtag = additionalInfos.Last().HasEtag;
resp = WebHelper.GetPropertyValue(updateUrl);
detail = new ExtensionRuleResultDetail(this.Name, entityId, HttpMethod.Get, string.Empty, resp);
if (HttpStatusCode.OK == resp.StatusCode || HttpStatusCode.NoContent == resp.StatusCode)
{
JProperty complexPropContent = null;
foreach (JProperty prop in reqData.Children <JProperty>())
{
if (prop.Name.Equals(complexPropName))
{
complexPropContent = prop;
break;
}
}
resp = WebHelper.UpdateComplexProperty(updateUrl, context.RequestHeaders, complexPropContent, hasEtag, complexPop.Value);
detail = new ExtensionRuleResultDetail(this.Name, updateUrl, HttpMethod.Patch, string.Empty, resp, string.Empty, reqDataStr);
if (HttpStatusCode.NoContent == resp.StatusCode)
{
resp = WebHelper.GetPropertyValue(updateUrl);
detail = new ExtensionRuleResultDetail(this.Name, updateUrl, HttpMethod.Get, string.Empty, resp, string.Empty, reqDataStr);
if (HttpStatusCode.OK == resp.StatusCode)
{
JObject value;
resp.ResponsePayload.TryToJObject(out value);
bool updated = true;
if (value != null && value.Type == JTokenType.Object)
{
foreach (var prop in value.Children <JProperty>())
{
if (complexPop.Value.Contains(prop.Name))
{
updated = prop.Value.ToString().Equals(Constants.UpdateData);
}
if (!updated)
{
passed = false;
detail.ErrorMessage = string.Format("The compelex property in request fails in HTTP patch updating.");
break;
}
}
if (updated)
{
passed = true;
}
}
}
else
{
passed = false;
detail.ErrorMessage = "Can not get the updated entity.";
}
}
else
{
passed = false;
detail.ErrorMessage = "HTTP Patch the complex property failed.";
}
}
else
{
detail.ErrorMessage = "Can not get the created entity from above URI.";
}
// Restore the service.
var resps = WebHelper.DeleteEntities(context.RequestHeaders, additionalInfos);
}
else
{
detail.ErrorMessage = "Created the new entity failed for above URI.";
}
var details = new List <ExtensionRuleResultDetail>()
{
detail
};
info = new ExtensionRuleViolationInfo(new Uri(updateUrl), serviceStatus.ServiceDocument, details);
return(passed);
}
public Element(JProperty property)
{
FullName = property.Name;
Hash = property.Property("hash").Value.ToString();
Size = long.Parse(property.Property("size").Value.ToString());
}
/// <summary>
/// Recursively sorts a JSON.NET JToken
/// </summary>
/// <param name="jtoken">The Internal tokenized representation of the JSON</param>
/// <returns>a recursively sorted JToken object</returns>
public static JToken Sort(JToken jtoken)
{
//base case 1: not a container
if (!(jtoken is JContainer))
{
return(jtoken);
}
bool childIsContainer = jtoken.ChildIsContainer();
var childType = jtoken.ChildType();
//base case 2: property and child is not a container
if (jtoken is JProperty && !childIsContainer)
{
return(jtoken);
}
//treat jtoken as container via jcontainer variable
var jcontainer = jtoken as JContainer;
//initialize a list of strings for storing serialized child tokens
var serializedElements = new SortedDictionary <string, JToken>();
//loop through all child tokens of the current token
var children = jcontainer.Children();
foreach (var child in children)
{
//recursively sort the child token
var sorted = Sort(child);
//serialize the sorted child token and add it to the string list
serializedElements.Add(sorted.ToString(), child);
}
//handle JProperty
if (jcontainer is JProperty && childIsContainer)
{
JContainer propValue;
if (childType == JTokenType.Array)
{
propValue = new JArray();
}
else
{
propValue = new JObject();
}
foreach (var key in serializedElements.Keys)
{
var sortedChildToAdd = serializedElements[key];
if (sortedChildToAdd.Type == JTokenType.Object && propValue.Type == JTokenType.Object)
{
propValue.Add(new JProperty((jcontainer as JProperty).Name, propValue));
}
else
{
propValue.Add(sortedChildToAdd);
}
}
jcontainer = new JProperty((jcontainer as JProperty).Name, propValue);
//handle JObject and JArray
}
else
{
jcontainer.RemoveAll();
foreach (var key in serializedElements.Keys)
{
jcontainer.Add(serializedElements[key]);
}
}
return(jcontainer);
}
public static JToken ReadJson(JsonTextReader jr, JToken own, bool isRoot = false)
{
if (own == null && isRoot)
{
own = new JObject();
}
JProperty jp = null;
while (jr.Read())
{
switch (jr.TokenType)
{
case JsonToken.StartObject:
{
JToken jo = null;
if (!isRoot)
{
jo = new JObject();
if (jp != null)
{
jp.Value = jo;
jp = null;
}
else if (own is JObject)
{
((JObject)own).Add(jo);
}
else if (own is JArray)
{
((JArray)own).Add(jo);
}
else
{
throw new Exception($"Неизвестный тип владельца {own.GetType()}");
}
}
else
{
jo = own;
}
ReadJson(jr, jo);
}
break;
case JsonToken.StartArray:
{
JToken jo = null;
if (!isRoot)
{
jo = new JArray();
if (jp != null)
{
jp.Value = jo;
jp = null;
}
else if (own is JObject)
{
((JObject)own).Add(jo);
}
else if (own is JArray)
{
((JArray)own).Add(jo);
}
else
{
throw new Exception($"Неправильный тип владельца {own.GetType()}");
}
}
else
{
jo = own;
}
ReadJson(jr, jo);
}
break;
case JsonToken.EndObject:
case JsonToken.EndArray:
return(own);
case JsonToken.PropertyName:
{
if (jp != null)
{
throw new Exception($"Свойство не сброшено {own.GetType()}");
}
jp = new JProperty(jr.Value.ToString().Replace("%#%", $"%#%_{FileId}"), null);
if (own is JObject)
{
((JObject)own).Add(jp);
}
else
{
throw new Exception($"Неправильный тип владельца {own.GetType()}");
}
}
break;
case JsonToken.String:
{
JValue jv = new JValue(jr.Value);
if (jv.Value.ToString().Contains("%#%"))
{
jv.Value = jv.Value.ToString().Replace("%#%", $"%#%_{FileId}");
}
if (jp != null)
{
jp.Value = jv;
}
else
{
if (own is JArray)
{
((JArray)own).Add(jv);
}
else
{
throw new Exception($"Неправильный тип владельца {own.GetType()}");
}
}
jp = null;
}
break;
case JsonToken.Boolean:
case JsonToken.Bytes:
case JsonToken.Date:
case JsonToken.Float:
case JsonToken.Integer:
case JsonToken.Null:
{
JValue jv = new JValue(jr.Value);
if (jp != null)
{
jp.Value = jv;
}
else
{
if (own is JArray)
{
((JArray)own).Add(jv);
}
else
{
throw new Exception($"Неправильный тип владельца {own.GetType()}");
}
}
jp = null;
}
break;
case JsonToken.None:
case JsonToken.Undefined:
break;
case JsonToken.Comment:
{
if (own is JObject)
{
string s = jr.Value.ToString().Trim().Replace("%#%", $"%#%_{FileId}");
if (s.ToLower().Contains("function"))
{
int i = s.IndexOf(':');
if (i > 0)
{
((JObject)own).Add(new JProperty(s.Substring(0, i), s.Substring(i + 1).Trim()));
}
}
}
}
break;
default:
throw new Exception($"Неправильный тип токена {jr.TokenType}");
}
}
return(own);
}
public static object ReadJsonStatic(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (objectType == typeof(string))
{
if (reader.TokenType == JsonToken.String)
{
var stringValue = reader.Value as string;
return(stringValue);
}
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
}
if (objectType.IsSubClassOfGeneric(typeof(IReferenceable)))
{
if (objectType.IsSubClassOfGeneric(typeof(IRef <>)))
{
var id = GetGuid();
if (id.IsDefault())
{
return(existingValue);
}
var refType = typeof(Ref <>).MakeGenericType(objectType.GenericTypeArguments);
return(Activator.CreateInstance(refType, id));
}
}
if (objectType.IsSubClassOfGeneric(typeof(IReferenceableOptional)))
{
if (objectType.IsSubClassOfGeneric(typeof(IRefOptional <>)))
{
var id = GetGuidMaybe();
if (id == null)
{
return(RefOptionalHelper.CreateEmpty(objectType.GenericTypeArguments.First()));
}
var refType = typeof(RefOptional <>).MakeGenericType(objectType.GenericTypeArguments);
return(Activator.CreateInstance(refType, id));
}
}
if (objectType.IsSubClassOfGeneric(typeof(IReferences)))
{
if (objectType.IsSubClassOfGeneric(typeof(IRefs <>)))
{
var ids = GetGuids();
var refType = typeof(Refs <>).MakeGenericType(objectType.GenericTypeArguments);
return(Activator.CreateInstance(refType, ids));
}
}
if (objectType.IsSubClassOfGeneric(typeof(IDictionary <,>)))
{
var dictionaryType = typeof(Dictionary <,>).MakeGenericType(objectType.GenericTypeArguments);
var instance = Activator.CreateInstance(dictionaryType);
if (reader.TokenType == JsonToken.StartArray)
{
var addMethod = dictionaryType.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance);
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
return(instance);
}
if (reader.TokenType != JsonToken.StartObject)
{
Console.WriteLine($"{reader.TokenType} != JsonToken.StartObject");
continue;
}
if (!reader.Read())
{
Console.WriteLine($"Reader terminated w/o finding JsonToken.EndArray");
return(instance);
}
if (!GetValue("key", objectType.GenericTypeArguments.First(), out object keyValue))
{
continue;
}
if (!GetValue("value", objectType.GenericTypeArguments.Last(), out object valueValue))
{
continue;
}
addMethod.Invoke(instance, new object[] { keyValue, valueValue });
if (reader.TokenType != JsonToken.EndObject)
{
Console.WriteLine($"{reader.TokenType} != JsonToken.EndObject");
}
//if (!reader.Read())
//{
// Console.WriteLine($"Reader terminated w/o finding JsonToken.EndArray (after kvp).");
// return instance;
//}
bool GetValue(string expectedName, Type type, out object value)
{
if (reader.TokenType != JsonToken.PropertyName)
{
value = null;
return(false);
}
var jprop = JProperty.Load(reader);
//Console.WriteLine($"Property[{jprop.Name}] = ({type.FullName}) {jprop.Value.Value<string>()}");
var name = jprop.Name;
var valueReader = jprop.Value.CreateReader();
value = serializer.Deserialize(valueReader, type);
if (expectedName.Equals(name, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
Console.WriteLine($"`{expectedName}` != `{name}`.");
return(false);
}
}
return(instance);
}
if (reader.TokenType == JsonToken.StartObject)
{
if (!reader.Read())
{
return(instance);
}
var addMethod = dictionaryType.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance);
do
{
Console.WriteLine($"{reader.Path} = ({reader.TokenType}) {reader.Value}");
if (reader.TokenType == JsonToken.EndObject)
{
return(instance);
}
if (reader.TokenType == JsonToken.PropertyName)
{
var jprop = JProperty.Load(reader);
var type = objectType.GenericTypeArguments.Last();
Console.WriteLine($"Property[{jprop.Name}] = ({type.FullName}) {jprop.Value.Value<string>()}");
var name = jprop.Name;
var value = serializer.Deserialize(jprop.Value.CreateReader(), type);
//var value = GetValue();
//object GetValue()
//{
// if (jprop.Value.Type == JTokenType.String)
// return jprop.Value.Value<string>();
// if (jprop.Value.Type == JTokenType.Guid)
// return jprop.Value.Value<Guid>();
// return jprop.Value.Value<object>();
//}
//var value = serializer.Deserialize(reader, type);
addMethod.Invoke(instance, new object[] { name, value });
continue;
}
else
{
Console.WriteLine($"Using path for {reader.TokenType}: {reader.Path} = {reader.Value}");
addMethod.Invoke(instance, new object[] { reader.Path, reader.Value });
if (!reader.Read())
{
return(instance);
}
}
} while (true);
}
return(instance);
}
if (objectType == typeof(byte[]))
{
if (reader.TokenType == JsonToken.String)
{
var bytesString = reader.Value as string;
return(bytesString.FromBase64String());
}
}
if (objectType == typeof(Type))
{
if (reader.TokenType == JsonToken.String)
{
var bytesString = reader.Value as string;
return(bytesString.GetClrType(
matched => matched,
() => default(Type)));
}
return(default(Type));
}
if (objectType.IsEnum)
{
if (reader.TokenType == JsonToken.String)
{
var enumString = reader.Value as string;
if (Enum.TryParse(objectType, enumString, out object enumValue))
{
return(enumValue);
}
}
}
return(existingValue);
Guid GetGuid()
{
if (reader.TokenType == JsonToken.String)
{
var guidString = reader.Value as string;
return(Guid.Parse(guidString));
}
if (reader.TokenType == JsonToken.Null)
{
return(default(Guid));
}
throw new Exception();
}
Guid?GetGuidMaybe()
{
if (reader.TokenType == JsonToken.Null)
{
return(default(Guid?));
}
return(GetGuid());
}
Guid[] GetGuids()
{
if (reader.TokenType == JsonToken.Null)
{
return new Guid[] { }
}
;
IEnumerable <Guid> Enumerate()
{
while (reader.TokenType != JsonToken.EndArray)
{
if (!reader.Read())
{
yield break;
}
var guidStr = reader.ReadAsString();
yield return(Guid.Parse(guidStr));
}
}
return(Enumerate().ToArray());
}
}
/// <summary>
/// Apply the merge using the UniqueKey to match items between JSON and entity.
/// </summary>
private static JsonEntityMergeResult MergeApplyUniqueKeyItems(JsonEntityMergeArgs args, IPropertyReflector pr, JProperty jp, object entity)
{
var hasError = false;
var hasChanges = false;
var count = 0;
var ukc = (UniqueKeyConfig)pr.Tag;
var lo = new List <object>();
var ier = pr.GetItemEntityReflector();
// Determine the unique key for a comparison.
var ukpr = ukc.GetPropertyReflectors(ier);
// Get the current value to update.
var current = (IEnumerable)pr.PropertyExpression.GetValue(entity);
if (current == null)
{
hasChanges = true;
}
// Merge each item into the new collection.
foreach (var ji in jp.Values())
{
// Check not null.
if (ji.Type != JTokenType.Object)
{
hasError = true;
args.Log(MessageItem.CreateErrorMessage(ji.Path, "The JSON token must be an object where Unique Key value(s) are required."));
continue;
}
// Generate the unique key from the json properties.
bool skip = false;
var uk = new object[ukpr.Length];
for (int i = 0; i < ukc.Properties.Length; i++)
{
var jk = ji[ukpr[i].JsonName];
if (jk == null)
{
hasError = skip = true;
args.Log(MessageItem.CreateErrorMessage(ji.Path, $"The JSON object must specify the '{ukpr[i].JsonName}' token as required for the unique key."));
break;
}
try
{
uk[i] = ukpr[i].GetJtokenValue(jk);
}
catch (FormatException fex)
{
hasError = skip = true;
args.Log(MessageItem.CreateMessage(jk.Path, MessageType.Error, $"The JSON token is malformed: {fex.Message}"));
break;
}
catch (Exception)
{
throw;
}
}
if (skip)
{
continue;
}
// Get existing by unique key.
var uniqueKey = new UniqueKey(uk);
var item = current == null ? null : ukc.IsEntityBaseCollection
? ((IEntityBaseCollection)current).GetByUniqueKey(uniqueKey)
: current.OfType <EntityBase>().FirstOrDefault(x => uniqueKey.Equals(x.UniqueKey));
// Create new if not found.
if (item == null)
{
hasChanges = true;
item = pr.ComplexTypeReflector.CreateItemValue();
}
// Update.
count++;
var mr = MergeApply(args, ier, ji, item);
if (mr == JsonEntityMergeResult.Error)
{
hasError = true;
}
else
{
if (mr == JsonEntityMergeResult.SuccessWithChanges)
{
hasChanges = true;
}
lo.Add(item);
}
}
if (hasError)
{
return(JsonEntityMergeResult.Error);
}
// Confirm nothing was deleted (only needed where nothing changed so far).
if (!hasChanges && count == (ukc.IsEntityBaseCollection ? ((IEntityBaseCollection)current).Count : current.OfType <EntityBase>().Count()))
{
return(JsonEntityMergeResult.SuccessNoChanges);
}
pr.ComplexTypeReflector.SetValue(entity, lo);
return(JsonEntityMergeResult.SuccessWithChanges);
}
public void IListIndexOf()
{
JProperty p = new JProperty("Test", 1);
IList l = new JObject(p);
Assert.Equal(0, l.IndexOf(p));
Assert.Equal(-1, l.IndexOf(new JProperty("Test", 1)));
}
public void IListCopyTo()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
object[] a = new object[l.Count];
l.CopyTo(a, 0);
Assert.Equal(p1, a[0]);
Assert.Equal(p2, a[1]);
}
public NavigatorState(JProperty pos)
{
Element = pos;
}
public void IListAddPropertyWithExistingName()
{
AssertException.Throws<ArgumentException>(() =>
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
JProperty p3 = new JProperty("Test2", "II");
l.Add(p3);
}, "Can not add property Test2 to OpenGamingLibrary.Json.Linq.JObject. Property with the same name already exists on object.");
}
public void ParseRef(JProperty jProperty, TestControl ctl)
{
JArray array = jProperty.Value as JArray;
List <string> excelNames = new List <string>();
if (array != null)
{
for (int i = 0; i < array.Count; i++)
{
var data = array[i];
var excelName = data.Value <string>();
excelNames.Add(excelName);
}
}
foreach (var name in excelNames)
{
if (!ctl.HasExcel(name))
{
SystemUtil.LogTestError(string.Format("({0}) 该表格不存在!", name), 4);
continue;
}
int idx = 5;
foreach (var v in Values)
{
idx++;
var listValue = ParseMultiValues(v);
if (listValue == null)
{
if (!ctl.HasExcelKey(name, v))
{
SystemUtil.LogTestError(string.Format("{0}.{1}.{2}.[{3}] ({4}行) 不存在于 [{5}] 中!",
owner.ExcelName,
owner.SheetName,
FieldName,
v,
idx,
name),
4);
}
}
else
{
for (int i = 0; i < listValue.Count; i++)
{
var lv = listValue[i];
if (!ctl.HasExcelKey(name, lv))
{
SystemUtil.LogTestError(string.Format("{0}.{1}.{2}.[{3}] ({4}行) 不存在于 [{5}] 中!",
owner.ExcelName,
owner.SheetName,
FieldName,
lv,
idx,
name)
, 4);
}
}
}
}
}
}
public void IListSetItem()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
JProperty p3 = new JProperty("Test3", "III");
l[0] = p3;
Assert.Equal(p3, l[0]);
Assert.Equal(p2, l[1]);
}
static bool Contains(JProperty main, JProperty sub)
{
return(Contains(main.Value, sub.Value));
}
public void IListIsSynchronized()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
Assert.False(l.IsSynchronized);
}
/// <summary>
/// Update a value in the configuration file.
/// </summary>
/// <typeparam name="T">The type of the value</typeparam>
/// <param name="scope">The ConfigScope of the configuration file to update.</param>
/// <param name="key">The string key of the value.</param>
/// <param name="value">The value to set.</param>
/// <param name="addValue">Whether the key-value pair should be added to or removed from the file.</param>
private void UpdateValueInFile <T>(ConfigScope scope, string key, T value, bool addValue)
{
string fileName = GetConfigFilePath(scope);
fileLock.EnterWriteLock();
try
{
// Since multiple properties can be in a single file, replacement
// is required instead of overwrite if a file already exists.
// Handling the read and write operations within a single FileStream
// prevents other processes from reading or writing the file while
// the update is in progress. It also locks out readers during write
// operations.
using (FileStream fs = WaitForFile(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
{
JObject jsonObject = null;
// UTF8, BOM detection, and bufferSize are the same as the basic stream constructor.
// The most important parameter here is the last one, which keeps the StreamReader
// (and FileStream) open during Dispose so that it can be reused for the write
// operation.
using (StreamReader streamRdr = new StreamReader(fs, Encoding.UTF8, true, 1024, true))
using (JsonTextReader jsonReader = new JsonTextReader(streamRdr))
{
// Safely determines whether there is content to read from the file
bool isReadSuccess = jsonReader.Read();
if (isReadSuccess)
{
// Read the stream into a root JObject for manipulation
jsonObject = (JObject)JToken.ReadFrom(jsonReader);
JProperty propertyToModify = jsonObject.Property(key);
if (propertyToModify == null)
{
// The property doesn't exist, so add it
if (addValue)
{
jsonObject.Add(new JProperty(key, value));
}
// else the property doesn't exist so there is nothing to remove
}
// The property exists
else
{
if (addValue)
{
propertyToModify.Replace(new JProperty(key, value));
}
else
{
propertyToModify.Remove();
}
}
}
else
{
// The file doesn't already exist and we want to write to it
// or it exists with no content.
// A new file will be created that contains only this value.
// If the file doesn't exist and a we don't want to write to it, no
// action is necessary.
if (addValue)
{
jsonObject = new JObject(new JProperty(key, value));
}
else
{
return;
}
}
}
// Reset the stream position to the beginning so that the
// changes to the file can be written to disk
fs.Seek(0, SeekOrigin.Begin);
// Update the file with new content
using (StreamWriter streamWriter = new StreamWriter(fs))
using (JsonTextWriter jsonWriter = new JsonTextWriter(streamWriter))
{
// The entire document exists within the root JObject.
// I just need to write that object to produce the document.
jsonObject.WriteTo(jsonWriter);
// This trims the file if the file shrank. If the file grew,
// it is a no-op. The purpose is to trim extraneous characters
// from the file stream when the resultant JObject is smaller
// than the input JObject.
fs.SetLength(fs.Position);
}
}
}
finally
{
fileLock.ExitWriteLock();
}
}
public void JPropertyContains()
{
JValue v = new JValue(1);
var p = new JProperty("TestProperty", v);
Assert.Equal(true, p.Contains(v));
Assert.Equal(false, p.Contains(new JValue(1)));
}
private void ProcessProperty(JProperty property)
{
ProcessToken(property.Value);
}
/// <summary>
/// Apply the merge as a full collection replacement; there is <b>no</b> way to detect changes or perform partial property update.
/// </summary>
private static JsonEntityMergeResult MergeApplyComplexItems(JsonEntityMergeArgs args, IPropertyReflector pr, JProperty jp, object entity)
{
var hasError = false;
var lo = new List <object>();
var ier = pr.GetItemEntityReflector();
foreach (var ji in jp.Values())
{
if (ji.Type == JTokenType.Null)
{
lo.Add(null);
continue;
}
var ival = pr.ComplexTypeReflector.CreateItemValue();
if (MergeApply(args, ier, ji, ival) == JsonEntityMergeResult.Error)
{
hasError = true;
}
else
{
lo.Add(ival);
}
}
if (hasError)
{
return(JsonEntityMergeResult.Error);
}
pr.ComplexTypeReflector.SetValue(entity, lo);
return(JsonEntityMergeResult.SuccessWithChanges);
}
private async Task TransitionInternalNodeConnectionString()
{
var nodes = LightningOptions.Value.InternalLightningByCryptoCode.Values.Select(c => c.ToString()).ToHashSet();
await using var ctx = _DBContextFactory.CreateContext();
foreach (var store in await ctx.Stores.AsQueryable().ToArrayAsync())
{
#pragma warning disable CS0618 // Type or member is obsolete
if (!string.IsNullOrEmpty(store.DerivationStrategy))
{
var noLabel = store.DerivationStrategy.Split('-')[0];
JObject jObject = new JObject();
jObject.Add("BTC", new JObject()
{
new JProperty("signingKey", noLabel),
new JProperty("accountDerivation", store.DerivationStrategy),
new JProperty("accountOriginal", store.DerivationStrategy),
new JProperty("accountKeySettings", new JArray()
{
new JObject()
{
new JProperty("accountKey", noLabel)
}
})
});
store.DerivationStrategies = jObject.ToString();
store.DerivationStrategy = null;
}
if (string.IsNullOrEmpty(store.DerivationStrategies))
{
continue;
}
var strats = JObject.Parse(store.DerivationStrategies);
bool updated = false;
foreach (var prop in strats.Properties().Where(p => p.Name.EndsWith("LightningLike", StringComparison.OrdinalIgnoreCase)))
{
var method = ((JObject)prop.Value);
var lightningCharge = method.Property("LightningChargeUrl", StringComparison.OrdinalIgnoreCase);
var ln = method.Property("LightningConnectionString", StringComparison.OrdinalIgnoreCase);
if (lightningCharge != null)
{
var chargeUrl = lightningCharge.Value.Value <string>();
var usr = method.Property("Username", StringComparison.OrdinalIgnoreCase)?.Value.Value <string>();
var pass = method.Property("Password", StringComparison.OrdinalIgnoreCase)?.Value.Value <string>();
updated = true;
if (chargeUrl != null)
{
var fullUri = new UriBuilder(chargeUrl)
{
UserName = usr,
Password = pass
}.Uri.AbsoluteUri;
var newStr = $"type=charge;server={fullUri};allowinsecure=true";
if (ln is null)
{
ln = new JProperty("LightningConnectionString", newStr);
method.Add(ln);
}
else
{
ln.Value = newStr;
}
}
foreach (var p in new[] { "Username", "Password", "LightningChargeUrl" })
{
method.Property(p, StringComparison.OrdinalIgnoreCase)?.Remove();
}
}
var paymentId = method.Property("PaymentId", StringComparison.OrdinalIgnoreCase);
if (paymentId != null)
{
paymentId.Remove();
updated = true;
}
if (ln is null)
{
continue;
}
if (nodes.Contains(ln.Value.Value <string>()))
{
updated = true;
ln.Value = null;
if (!(method.Property("InternalNodeRef", StringComparison.OrdinalIgnoreCase) is JProperty internalNode))
{
internalNode = new JProperty("InternalNodeRef", null);
method.Add(internalNode);
}
internalNode.Value = new JValue(LightningSupportedPaymentMethod.InternalNode);
}
}
if (updated)
{
store.DerivationStrategies = strats.ToString();
}
#pragma warning restore CS0618 // Type or member is obsolete
}
await ctx.SaveChangesAsync();
}
public void ListChanged()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
var o = new JObject(p1, p2);
ListChangedType? changedType = null;
int? index = null;
o.ListChanged += (s, a) =>
{
changedType = a.ListChangedType;
index = a.NewIndex;
};
JProperty p3 = new JProperty("Test3", "III");
o.Add(p3);
Assert.Equal(changedType, ListChangedType.ItemAdded);
Assert.Equal(index, 2);
Assert.Equal(p3, ((IList<JToken>)o)[index.Value]);
JProperty p4 = new JProperty("Test4", "IV");
((IList<JToken>)o)[index.Value] = p4;
Assert.Equal(changedType, ListChangedType.ItemChanged);
Assert.Equal(index, 2);
Assert.Equal(p4, ((IList<JToken>)o)[index.Value]);
Assert.False(((IList<JToken>)o).Contains(p3));
Assert.True(((IList<JToken>)o).Contains(p4));
o["Test1"] = 2;
Assert.Equal(changedType, ListChangedType.ItemChanged);
Assert.Equal(index, 0);
Assert.Equal(2, (int)o["Test1"]);
}
public override bool VisitPackage(JProperty package, string projectJsonPath)
{
var patterns = Enumerable.Empty <ValidationPattern>();
if (ValidationPatterns != null)
{
patterns = ValidationPatterns
.Select(item => new ValidationPattern(item, Log))
.ToArray();
}
string id = package.Name;
string version;
if (package.Value is JObject)
{
JToken target = package.Value["target"];
if (target != null && target.Value <string>() == "project")
{
return(false);
}
version = package.Value["version"].Value <string>();
}
else if (package.Value is JValue)
{
version = package.Value.ToObject <string>();
}
else
{
throw new ArgumentException(string.Format(
"Unrecognized dependency element for {0} in {1}",
package.Name,
projectJsonPath));
}
string dependencyMessage = string.Format(
"{0} {1} in {2}",
id,
version,
projectJsonPath);
bool packageUpdated = false;
foreach (var pattern in patterns)
{
packageUpdated |= pattern.VisitPackage(
package,
id,
version,
dependencyMessage,
UpdateInvalidDependencies);
}
if (!packageUpdated && ProhibitFloatingDependencies && version.Contains('*'))
{
// A * dependency was found but it hasn't been fixed. It might not have been fixed
// because UpdateInvalidDependencies = false or because a pattern didn't match it:
// either way this is an error.
Log.LogError("Floating dependency detected: {0}", dependencyMessage);
}
return(packageUpdated);
}
public void IListContains()
{
JProperty p = new JProperty("Test", 1);
IList l = new JObject(p);
Assert.True(l.Contains(p));
Assert.False(l.Contains(new JProperty("Test", 1)));
}
public bool VisitPackage(
JProperty package,
string packageId,
string version,
string dependencyMessage,
bool updateInvalidDependencies)
{
bool updatedPackage = false;
string newVersion = version;
var dependencyVersionRange = VersionRange.Parse(version);
NuGetVersion dependencyVersion = dependencyVersionRange.MinVersion;
LogAction logAction;
string logPreamble;
if (updateInvalidDependencies)
{
logAction = _log.LogWarning;
logPreamble = "Fixing invalid dependency: ";
}
else
{
logAction = _log.LogError;
logPreamble = "Dependency validation error: ";
}
logPreamble += "for " + dependencyMessage;
if (_idPattern.IsMatch(packageId))
{
if (!string.IsNullOrWhiteSpace(_expectedVersion) && _expectedVersion != version)
{
if (updateInvalidDependencies)
{
newVersion = _expectedVersion;
updatedPackage = true;
}
logAction(
"{0} package version is '{1}' but expected '{2}' for packages matching '{3}'",
logPreamble,
version,
_expectedVersion,
_idPattern);
}
if (!string.IsNullOrWhiteSpace(_expectedPrerelease) &&
dependencyVersion.IsPrerelease &&
_expectedPrerelease != dependencyVersion.Release)
{
if (updateInvalidDependencies)
{
newVersion = new NuGetVersion(
dependencyVersion.Major,
dependencyVersion.Minor,
dependencyVersion.Patch,
_expectedPrerelease,
dependencyVersion.Metadata).ToNormalizedString();
updatedPackage = true;
}
logAction(
"{0} package prerelease is '{1}', but expected '{2}' for packages matching '{3}'",
logPreamble,
dependencyVersion.Release,
_expectedPrerelease,
_idPattern);
}
}
if (updatedPackage)
{
if (package.Value is JObject)
{
package.Value["version"] = newVersion;
}
else
{
package.Value = newVersion;
}
}
return(updatedPackage);
}
public void IListClear()
{
JProperty p = new JProperty("Test", 1);
IList l = new JObject(p);
Assert.Equal(1, l.Count);
l.Clear();
Assert.Equal(0, l.Count);
}
public object ToJsonObject()
{
var content = new JProperty("highlight", new JObject());
if (_tagsSchema != null)
{
content.Value["tags_schema"] = _tagsSchema;
}
if (_preTags != null)
{
content.Value["pre_tags"] = new JArray(_preTags);
}
if (_postTags != null)
{
content.Value["post_tags"] = new JArray(_postTags);
}
if (_order != null)
{
content.Value["order"] = _order;
}
if (_encoder != null)
{
content.Value["encoder"] = _encoder;
}
if (_fields != null && _fields.Count > 0)
{
content.Value["fields"] = new JObject();
foreach (var field in _fields)
{
content.Value["fields"][field.Name()] = new JObject();
if (field.FragmentSize().HasValue)
{
var fragmentSize = field.FragmentSize();
if (fragmentSize != null)
{
content.Value["fields"][field.Name()]["fragment_size"] = fragmentSize.Value;
}
}
if (field.NumOfFragments().HasValue)
{
var numOfFragments = field.NumOfFragments();
if (numOfFragments != null)
{
content.Value["fields"][field.Name()]["number_of_fragments"] = numOfFragments.Value;
}
}
if (field.FragmentOffset().HasValue)
{
var fragmentOffset = field.FragmentOffset();
if (fragmentOffset != null)
{
content.Value["fields"][field.Name()]["fragment_offset"] = fragmentOffset.Value;
}
}
}
}
return(content);
}
public void IListAdd()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
JProperty p3 = new JProperty("Test3", "III");
l.Add(p3);
Assert.Equal(3, l.Count);
Assert.Equal(p3, l[2]);
}
public static bool FindSchema(Action <JSchema> setSchema, JSchema schema, Uri rootSchemaId, Uri reference, JSchemaReader schemaReader, ref JSchemaDiscovery discovery)
{
// todo, better way to get parts from Uri
string[] parts = reference.ToString().Split('/');
bool resolvedSchema;
if (parts.Length > 0 && (parts[0] == "#" || parts[0] == rootSchemaId + "#"))
{
schemaReader._schemaStack.Push(schema);
parts = parts.Skip(1).ToArray();
object current = schema;
foreach (string part in parts)
{
string unescapedPart = UnescapeReference(part);
if (current is JSchema)
{
JSchema s = current as JSchema;
schemaReader._schemaStack.Push(s);
switch (unescapedPart)
{
case Constants.PropertyNames.Properties:
current = s._properties;
break;
case Constants.PropertyNames.Items:
current = s._items;
break;
case Constants.PropertyNames.AdditionalProperties:
current = s.AdditionalProperties;
break;
case Constants.PropertyNames.AdditionalItems:
current = s.AdditionalItems;
break;
case Constants.PropertyNames.Not:
current = s.Not;
break;
case Constants.PropertyNames.OneOf:
current = s._oneOf;
break;
case Constants.PropertyNames.AllOf:
current = s._allOf;
break;
case Constants.PropertyNames.AnyOf:
current = s._anyOf;
break;
case Constants.PropertyNames.Enum:
current = s._enum;
break;
case Constants.PropertyNames.PatternProperties:
current = s._patternProperties;
break;
case Constants.PropertyNames.Dependencies:
current = s._dependencies;
break;
default:
JToken t;
s.ExtensionData.TryGetValue(unescapedPart, out t);
current = t;
break;
}
}
else if (current is JToken)
{
JToken resolvedToken;
JToken t = (JToken)current;
if (t is JObject)
{
resolvedToken = t[unescapedPart];
}
else if (t is JArray || t is JConstructor)
{
int index;
if (int.TryParse(unescapedPart, NumberStyles.None, CultureInfo.InvariantCulture, out index))
{
if (index > t.Count() || index < 0)
{
resolvedToken = null;
}
else
{
resolvedToken = t[index];
}
}
else
{
resolvedToken = null;
}
}
else
{
resolvedToken = null;
}
if (resolvedToken != null)
{
JSchemaAnnotation annotation = resolvedToken.Annotation <JSchemaAnnotation>();
if (annotation != null)
{
current = annotation.Schema;
}
else
{
current = resolvedToken;
}
}
else
{
current = null;
}
}
else if (current is IDictionary)
{
IDictionary d = (IDictionary)current;
current = d[unescapedPart];
}
else if (current is IList)
{
IList l = (IList)current;
int index;
if (int.TryParse(unescapedPart, NumberStyles.None, CultureInfo.InvariantCulture, out index))
{
if (index > l.Count || index < 0)
{
current = null;
}
else
{
current = l[index];
}
}
else
{
current = null;
}
}
else
{
break;
}
}
if (current is JToken)
{
JToken t = (JToken)current;
JSchemaAnnotation annotation = t.Annotation <JSchemaAnnotation>();
if (annotation != null)
{
setSchema(annotation.Schema);
resolvedSchema = true;
}
else
{
JSchema inlineSchema = schemaReader.ReadInlineSchema(setSchema, t);
string path = reference.OriginalString;
if (path.StartsWith("#/", StringComparison.Ordinal))
{
path = path.Substring(2, path.Length - 2);
}
discovery.Discover(inlineSchema, rootSchemaId, path);
resolvedSchema = true;
}
}
else
{
JSchema s = current as JSchema;
if (s != null)
{
setSchema(s);
resolvedSchema = true;
// schema is a reference schema and needs to be resolved
if (s.Reference != null)
{
schemaReader.AddDeferedSchema(setSchema, s);
}
}
else
{
resolvedSchema = false;
}
}
schemaReader._schemaStack.Clear();
}
else
{
discovery.Discover(schema, null);
Uri resolvedReference = ResolveSchemaId(rootSchemaId, reference);
// use firstordefault to handle duplicates
KnownSchema knownSchema = discovery.KnownSchemas.FirstOrDefault(s => UriComparer.Instance.Equals(s.Id, resolvedReference));
if (knownSchema != null)
{
resolvedSchema = true;
setSchema(knownSchema.Schema);
}
else
{
int hashIndex = resolvedReference.OriginalString.IndexOf('#');
if (hashIndex != -1)
{
Uri path = new Uri(resolvedReference.OriginalString.Substring(0, hashIndex), UriKind.RelativeOrAbsolute);
Uri fragment = new Uri(resolvedReference.OriginalString.Substring(hashIndex), UriKind.RelativeOrAbsolute);
// there could be duplicated ids. use FirstOrDefault to get first schema with an id
knownSchema = discovery.KnownSchemas.FirstOrDefault(s => UriComparer.Instance.Equals(s.Id, path));
if (knownSchema != null)
{
// don't attempt to find a schema in the same schema again
// avoids stackoverflow
if (knownSchema.Schema != schema ||
!UriComparer.Instance.Equals(rootSchemaId, path) ||
!UriComparer.Instance.Equals(reference, fragment))
{
resolvedSchema = FindSchema(setSchema, knownSchema.Schema, path, fragment, schemaReader, ref discovery);
}
else
{
resolvedSchema = false;
}
}
else
{
resolvedSchema = false;
}
}
else
{
// special case
// look in the root schema's definitions for a definition with the same property name and id as reference
JToken definitions;
if (schema.ExtensionData.TryGetValue(Constants.PropertyNames.Definitions, out definitions))
{
JObject definitionsObject = definitions as JObject;
if (definitionsObject != null)
{
JProperty matchingProperty = definitionsObject.Properties().FirstOrDefault(p => TryCompare(p.Name, resolvedReference));
JObject o = matchingProperty?.Value as JObject;
if (o != null && TryCompare((string)o["id"], resolvedReference))
{
JSchema inlineSchema = schemaReader.ReadInlineSchema(setSchema, o);
discovery.Discover(inlineSchema, rootSchemaId, Constants.PropertyNames.Definitions + "/" + resolvedReference.OriginalString);
resolvedSchema = true;
}
else
{
resolvedSchema = false;
}
}
else
{
resolvedSchema = false;
}
}
else
{
resolvedSchema = false;
}
}
}
}
return(resolvedSchema);
}
public void IListAddBadValue()
{
AssertException.Throws<ArgumentException>(() =>
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
l.Add("Bad!");
}, "Argument is not a JToken.");
}
public IPathSegment CreatePathSegment(JProperty jProperty)
{
return(new JsonPathSegment(jProperty.Name, jProperty.IsEnumerable()));
}
public void IListRemove()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
JProperty p3 = new JProperty("Test3", "III");
// won't do anything
l.Remove(p3);
Assert.Equal(2, l.Count);
l.Remove(p1);
Assert.Equal(1, l.Count);
Assert.False(l.Contains(p1));
Assert.True(l.Contains(p2));
l.Remove(p2);
Assert.Equal(0, l.Count);
Assert.False(l.Contains(p2));
Assert.Equal(null, p2.Parent);
}
protected override void ProcessRecord()
{
var nestedresource = new Models.NestedResourceTemplate()
{
name = ResourceName
};
nestedresource.properties.templateLink.uri = String.Format(NestedTemplateResourceUri, ResourceName);
if (AddParameterlink)
{
nestedresource.properties.parametersLink.uri = String.Format(NestedTemplateParameterUri, ResourceName);
}
else
{
nestedresource.properties.parametersLink = null;
nestedresource.properties.parameters = new JObject();
if (!string.IsNullOrEmpty(DependsOn))
{
nestedresource.dependsOn.Add(DependsOn);
}
var fileName = Path.Combine(ResourcePath, Path.GetFileName(ResourcePath) + ".json");
using (Stream stream = File.OpenRead(fileName))
{
using (StreamReader reader = new StreamReader(stream))
{
var nestedTemplate2 = new JsonTextReader(reader);
JsonSerializer se = new JsonSerializer();
dynamic parsedData = se.Deserialize(nestedTemplate2);
JObject parameters = parsedData["parameters"];
foreach (JProperty parameter in parameters.Properties())
{
JProperty param = parameter.DeepClone() as JProperty;
if (nestedtemplate.parameters.ContainsKey(parameter.Name))
{
var v1 = (JObject)nestedtemplate.parameters[parameter.Name]; //.Value["defaultValue"]?.Value<string>();\
//v1.Properties[""];
foreach (var p in nestedtemplate.parameters.Properties())
{
if (p.Name.StartsWith($"{parameter.Name}"))
{
var p1 = p.Value["defaultValue"];
var p2 = parameter.Value["defaultValue"];
if (JToken.DeepEquals(p1, p2))
{
param = p;
break;
}
}
}
var existingParam = nestedtemplate.parameters.Properties().FirstOrDefault(p => p.Name.StartsWith($"{parameter.Name}") && JToken.DeepEquals(p.Value["defaultValue"], parameter.Value["defaultValue"]));
if (existingParam == null)
{
var paramName = GetUniqueParamName(parameter.Name);
param = new JProperty($"{paramName}", parameter.Value);
nestedtemplate.parameters.Add(param);
}
}
else
{
nestedtemplate.parameters.Add(param);
}
nestedresource.properties.parameters.Add(parameter.Name, JObject.FromObject(new { value = $"[parameters('{param.Name}')]" }));
}
}
}
}
nestedtemplate.resources.Add(JObject.FromObject(nestedresource));
var result = JObject.FromObject(nestedtemplate);
Sort(result["parameters"]);
WriteObject(result.ToString());
}
public void IListInsert()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
JProperty p3 = new JProperty("Test3", "III");
l.Insert(1, p3);
Assert.Equal(l, p3.Parent);
Assert.Equal(p1, l[0]);
Assert.Equal(p3, l[1]);
Assert.Equal(p2, l[2]);
}
public virtual void Visit(JProperty property)
{
Visit(property.Value);
}
public void IListSetItemAlreadyExists()
{
AssertException.Throws<ArgumentException>(() =>
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
JProperty p3 = new JProperty("Test3", "III");
l[0] = p3;
l[1] = p3;
}, "Can not add property Test3 to OpenGamingLibrary.Json.Linq.JObject. Property with the same name already exists on object.");
}
private void VisitProperty(JProperty property)
{
VisitToken(property.Value);
}
public void IListSyncRoot()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
IList l = new JObject(p1, p2);
Assert.NotNull(l.SyncRoot);
}
private JObject GetAssessedGroups(JObject gppCategory)
{
Dictionary <string, Dictionary <string, string> > assessedGroupsDict = new Dictionary <string, Dictionary <string, string> >();
Dictionary <string, Dictionary <string, string> > assessedUsersDict = new Dictionary <string, Dictionary <string, string> >();
foreach (JToken gppUsers in gppCategory.SelectTokens("User"))
{
foreach (JToken gppUser in gppUsers)
{
// dictionary for results from this specific user.
Dictionary <string, string> assessedUserDict = new Dictionary <string, string>
{
{ "InterestLevel", "3" }
};
JToken gppUserProps = gppUser["Properties"];
// check what the entry is doing to the user and turn it into real word
string userAction = GetActionString(gppUserProps["@action"].ToString());
assessedUserDict.Add("Action", userAction);
// get the username and a bunch of other details:
assessedUserDict.Add("Name", gppUser["@name"].ToString());
assessedUserDict.Add("User Name", gppUserProps["@userName"].ToString());
assessedUserDict.Add("DateTime Changed", gppUser["@changed"].ToString());
assessedUserDict.Add("Account Disabled", gppUserProps["@acctDisabled"].ToString());
assessedUserDict.Add("Password Never Expires", gppUserProps["@neverExpires"].ToString());
assessedUserDict.Add("Description", gppUserProps["@description"].ToString());
assessedUserDict.Add("Full Name", gppUserProps["@fullName"].ToString());
assessedUserDict.Add("New Name", gppUserProps["@newName"].ToString());
// check for cpasswords
string cpassword = gppUserProps["@cpassword"].ToString();
if (cpassword.Length > 0)
{
string decryptedCpassword = "";
decryptedCpassword = Utility.DecryptCpassword(cpassword);
// if we find one, that's super interesting.
assessedUserDict.Add("Cpassword", decryptedCpassword);
assessedUserDict["InterestLevel"] = "10";
}
// add to the output dict with a uid to keep it unique.
assessedUsersDict.Add(gppUser["@uid"].ToString(), assessedUserDict);
}
}
// repeat the process for Groups
foreach (JToken gppGroups in gppCategory.SelectTokens("Group"))
{
foreach (JToken gppGroup in gppGroups)
{
//dictionary for results from this specific group
Dictionary <string, string> assessedGroupDict = new Dictionary <string, string>
{
{ "InterestLevel", "3" }
};
JToken gppGroupProps = gppGroup["Properties"];
// check what the entry is doing to the group and turn it into real word
string groupAction = gppGroupProps["@action"].ToString();
groupAction = GetActionString(groupAction);
// get the group name and a bunch of other details:
assessedGroupDict.Add("Name", gppGroup["@name"].ToString());
//assessedGroupDict.Add("User Name", gppGroupProps["@userName"].ToString());
assessedGroupDict.Add("DateTime Changed", gppGroup["@changed"].ToString());
assessedGroupDict.Add("Description", gppGroupProps["@description"].ToString());
assessedGroupDict.Add("New Name", gppGroupProps["@newName"].ToString());
assessedGroupDict.Add("Delete All Users", gppGroupProps["@deleteAllUsers"].ToString());
assessedGroupDict.Add("Delete All Groups", gppGroupProps["@deleteAllGroups"].ToString());
assessedGroupDict.Add("Remove Accounts", gppGroupProps["@removeAccounts"].ToString());
assessedGroupDict.Add("Action", groupAction);
Utility.DebugWrite("You still need to figure out group members.");
//Utility.DebugWrite(gppGroupProps["Members"].ToString());
// add to the output dict with a uid to keep it unique.
assessedGroupsDict.Add(gppGroup["@uid"].ToString(), assessedGroupDict);
}
}
// cast our Dictionaries back into JObjects
JProperty assessedUsersJson = new JProperty("gpp User settings", JToken.FromObject(assessedUsersDict));
JProperty assessedGroupsJson = new JProperty("gpp Group settings", JToken.FromObject(assessedGroupsDict));
// chuck the users and groups together in one JObject
JObject assessedGppGroupsJson = new JObject();
// only want to actually output these things if there's anything useful in them.
if (assessedUsersDict.Count > 0)
{
assessedGppGroupsJson.Add(assessedUsersJson);
}
if (assessedGroupsDict.Count > 0)
{
assessedGppGroupsJson.Add(assessedGroupsJson);
}
return(assessedGppGroupsJson);
}
public void JPropertyLinq()
{
var p = new JProperty("TestProperty", null);
IList l = p;
List<JToken> result = l.Cast<JToken>().ToList();
Assert.Equal(1, result.Count);
}
public void BatchingProcessTest()
{
EventListener.NestedLoggerHandler += eventData =>
{
if (eventData.EventId == (int)SharedLogEventId.CacheMissAnalysisBatchResults)
{
m_cacheMissAnalysisBatchList.Add(eventData.Payload.ToArray()[0].ToString());
}
};
m_cacheMissAnalysisBatchList = new List <string>();
var lenUnit = 100;
var string1 = new string('a', lenUnit);
var string2 = new string('b', 2 * lenUnit);
var string3 = new string('c', 3 * lenUnit);
var string4 = new string('d', 4 * lenUnit);
var string5 = new string('e', 3 * lenUnit);
var string6 = new string('f', 2 * lenUnit);
var string7 = new string('g', lenUnit);
var results = new List <JProperty>();
JProperty result1 = new JProperty("p1", new JObject(new JProperty("Result", string1)));
JProperty result2 = new JProperty("P2", new JObject(new JProperty("Result", string2)));
JProperty result3 = new JProperty("P3", new JObject(new JProperty("Result", string3)));
JProperty result4 = new JProperty("P4", new JObject(new JProperty("Result", string4)));
JProperty result5 = new JProperty("P5", new JObject(new JProperty("Result", string5)));
JProperty result6 = new JProperty("P6", new JObject(new JProperty("Result", string6)));
JProperty result7 = new JProperty("P7", new JObject(new JProperty("Result", string7)));
results.Add(result1);
results.Add(result2);
results.Add(result3);
results.Add(result4);
results.Add(result5);
results.Add(result6);
results.Add(result7);
var result1Len = result1.Name.Length + result1.Value.ToString().Length;
var result2Len = result2.Name.Length + result2.Value.ToString().Length;
var result3Len = result3.Name.Length + result3.Value.ToString().Length;
var result4Len = result4.Name.Length + result4.Value.ToString().Length;
var result5Len = result5.Name.Length + result5.Value.ToString().Length;
var result6Len = result6.Name.Length + result6.Value.ToString().Length;
var result7Len = result7.Name.Length + result7.Value.ToString().Length;
var timer = new Timer(o => { XAssert.IsTrue(false, "Process Timeout."); }, null, 10000, 10000);
// 1 batch per process
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = result1Len + result2Len + result3Len + result4Len + result5Len + result6Len + result7Len + 1;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 1, "Should have 1 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], string1, string2, string3, string4, string5, string6, string7);
m_cacheMissAnalysisBatchList.Clear();
// 2 batch per process
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = result1Len + result2Len + result3Len + result4Len + 1;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 2, "Should have 2 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], string1, string2, string3, string4);
XAssert.Contains(m_cacheMissAnalysisBatchList[1], string5, string6, string7);
m_cacheMissAnalysisBatchList.Clear();
// batch - single - batch in a process
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = result1Len + result2Len + result3Len + 20;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 3, "Should have 3 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], string1, string2, string3);
XAssert.Contains(m_cacheMissAnalysisBatchList[1], string4);
XAssert.Contains(m_cacheMissAnalysisBatchList[2], string5, string6, string7);
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[2], string4); // Make sure there no previous result in it
m_cacheMissAnalysisBatchList.Clear();
// batch - single - single - single - batch in a process
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = result1Len + result2Len + 1;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 5, "Should have 5 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], string1, string2);
XAssert.Contains(m_cacheMissAnalysisBatchList[1], string3);
XAssert.Contains(m_cacheMissAnalysisBatchList[2], string4.Substring(string4.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[2], string4);
XAssert.Contains(m_cacheMissAnalysisBatchList[2], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[3], string5);
XAssert.Contains(m_cacheMissAnalysisBatchList[4], string6, string7);
m_cacheMissAnalysisBatchList.Clear();
// all single in a process
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = result1Len + 1;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 7, "Should have 7 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], string1);
XAssert.Contains(m_cacheMissAnalysisBatchList[1], string2.Substring(string2.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[1], string2);
XAssert.Contains(m_cacheMissAnalysisBatchList[1], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[2], string3.Substring(string3.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[2], string3);
XAssert.Contains(m_cacheMissAnalysisBatchList[2], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[3], string4.Substring(string4.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[3], string4);
XAssert.Contains(m_cacheMissAnalysisBatchList[3], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[4], string5.Substring(string5.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[4], string5);
XAssert.Contains(m_cacheMissAnalysisBatchList[4], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[5], string6.Substring(string6.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[5], string6);
XAssert.Contains(m_cacheMissAnalysisBatchList[5], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[6], string7);
m_cacheMissAnalysisBatchList.Clear();
// all single in a process, test a result's len == maxLogLen
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = result3Len;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 7, "Should have 7 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], string1);
XAssert.Contains(m_cacheMissAnalysisBatchList[1], string2);
XAssert.Contains(m_cacheMissAnalysisBatchList[2], string3.Substring(string4.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));// Result has exact length as maxLogLen
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[2], string3);
XAssert.Contains(m_cacheMissAnalysisBatchList[2], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[3], string4.Substring(string4.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[3], string4);
XAssert.Contains(m_cacheMissAnalysisBatchList[3], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[4], string5.Substring(string4.Length - Configuration.Logging.AriaIndividualMessageSizeLimitBytes / 2 + 20));// Result has exact length as maxLogLen
XAssert.ContainsNot(m_cacheMissAnalysisBatchList[4], string5);
XAssert.Contains(m_cacheMissAnalysisBatchList[4], "[...]");
XAssert.Contains(m_cacheMissAnalysisBatchList[5], string6);
XAssert.Contains(m_cacheMissAnalysisBatchList[6], string7);
m_cacheMissAnalysisBatchList.Clear();
timer.Dispose();
}
public void JPropertyIndexOf()
{
JValue v = new JValue(1);
JProperty p1 = new JProperty("TestProperty", v);
IList l1 = p1;
Assert.Equal(0, l1.IndexOf(v));
IList<JToken> l2 = p1;
Assert.Equal(0, l2.IndexOf(v));
}
public void BatchingRealResultTruncateTest()
{
EventListener.NestedLoggerHandler += eventData =>
{
if (eventData.EventId == (int)SharedLogEventId.CacheMissAnalysisBatchResults)
{
m_cacheMissAnalysisBatchList.Add(eventData.Payload.ToArray()[0].ToString());
}
};
var results = new List <JProperty>();
string resultJson = @"{
""Description"": ""PipC1907BAC23BB4039, test"",
""FromCacheLookup"": false,
""Detail"": {
""ActualMissType"": ""MissForDescriptorsDueToStrongFingerprints"",
""ReasonFromAnalysis"": ""WeakFingerprints of the builds are different."",
""Info"": {
""WeakFingerprintMismatchResult"": {
""WeakFingerprint"": {
""Old"": ""126B618310A6F95C4B00E9A576CFE5EAF3B5D950"",
""New"": ""311C6E5835CEA28399F62FACCA5380C8C18347E5""
},
""ExecutionAndFingerprintOptions"": {
""Changed"": {
""FingerprintVersion"": {
""Old"": ""80"",
""New"": ""81""
}
}
},
""Executable"": {
""Old"": ""path1"",
""New"": ""path2""
},
""UntrackedPaths"": {
""Added"": [
""path3""
],
""Removed"": [
""Path4""
]
},
""OldProvenance:"": {
""SessionId"": ""fa485571-0100-ffff-0f37-d21e6b002ba0"",
""RelatedSessionId"": ""5c4a3e30-dd7e-4cc1-864a-d21e6b002ba0""
}
}
}
}
}" ;
m_cacheMissAnalysisBatchList = new List <string>();
var pipHash = "PipC1907BAC23BB4039";
JProperty result = new JProperty(pipHash, JObject.Parse(resultJson));
results.Add(result);
RuntimeCacheMissAnalyzer.s_numberOfBatchesLogged = 0;
Configuration.Logging.AriaIndividualMessageSizeLimitBytes = 600;
RuntimeCacheMissAnalyzer.ProcessResults(results.ToArray(), Configuration, LoggingContext);
XAssert.AreEqual(m_cacheMissAnalysisBatchList.Count, 1, "Should have 1 batch logging.");
XAssert.Contains(m_cacheMissAnalysisBatchList[0], pipHash);
XAssert.Contains(m_cacheMissAnalysisBatchList[0], "[...]");
m_cacheMissAnalysisBatchList.Clear();
}
public void MultiContentConstructor()
{
var p = new JProperty("error", new List<string> { "one", "two" });
JArray a = (JArray)p.Value;
Assert.Equal(a.Count, 2);
Assert.Equal("one", (string)a[0]);
Assert.Equal("two", (string)a[1]);
}
static bool IsBaseType(JProperty property) => IsBaseType(property.Value as JObject);
/// <summary>
/// Unpatch a JSON object
/// </summary>
/// <param name="right">Patched JSON object</param>
/// <param name="patch">JSON Patch Document</param>
/// <returns>Unpatched JSON object</returns>
/// <exception cref="System.IO.InvalidDataException">Thrown if the patch document is invalid</exception>
public JToken Unpatch(JToken right, JToken patch)
{
if (patch == null)
{
return(right);
}
if (patch.Type == JTokenType.Object)
{
var patchObj = (JObject)patch;
JProperty arrayDiffCanary = patchObj.Property("_t");
if (right != null &&
right.Type == JTokenType.Array &&
arrayDiffCanary != null &&
arrayDiffCanary.Value.Type == JTokenType.String &&
arrayDiffCanary.ToObject <string>() == "a")
{
return(ArrayUnpatch((JArray)right, patchObj));
}
return(ObjectUnpatch(right as JObject, patchObj));
}
if (patch.Type == JTokenType.Array)
{
var patchArray = (JArray)patch;
if (patchArray.Count == 1) // Add (we need to remove the property)
{
return(null);
}
else if (patchArray.Count == 2) // Replace
{
return(patchArray[0]);
}
else if (patchArray.Count == 3) // Delete, Move or TextDiff
{
if (patchArray[2].Type != JTokenType.Integer)
{
throw new InvalidDataException("Invalid patch object");
}
int op = patchArray[2].Value <int>();
if (op == 0)
{
return(patchArray[0]);
}
else if (op == 2)
{
var dmp = new diff_match_patch();
List <Patch> patches = dmp.patch_fromText(patchArray[0].ToObject <string>());
if (patches.Count != 1)
{
throw new InvalidDataException("Invalid textline");
}
string left = dmp.diff_text1(patches[0].diffs);
return(left);
}
else
{
throw new InvalidDataException("Invalid patch object");
}
}
else
{
throw new InvalidDataException("Invalid patch object");
}
}
return(null);
}
/// <summary>
/// Apply the merge from the json to the entity value as a more complex type.
/// </summary>
private static JsonEntityMergeResult MergeApplyComplex(JsonEntityMergeArgs args, IPropertyReflector pr, JProperty jp, object entity)
{
if (jp.Value.Type == JTokenType.Null)
{
return(pr.SetValue(entity, null) ? JsonEntityMergeResult.SuccessWithChanges : JsonEntityMergeResult.SuccessNoChanges);
}
// Update the sub-entity.
if (pr.ComplexTypeReflector.ComplexTypeCode == ComplexTypeCode.Object)
{
if (jp.Value.Type != JTokenType.Object)
{
return(args.Log(MessageItem.CreateMessage(jp.Path, MessageType.Error, $"The JSON token is malformed and could not be parsed.")));
}
var hasChanged = true;
var current = pr.PropertyExpression.GetValue(entity);
if (current == null)
{
current = pr.NewValue(entity).value;
}
else
{
hasChanged = false;
}
var mr = MergeApply(args, pr.GetEntityReflector(), jp.Value, current);
return(mr == JsonEntityMergeResult.SuccessNoChanges ? (hasChanged ? JsonEntityMergeResult.SuccessWithChanges : JsonEntityMergeResult.SuccessNoChanges) : mr);
}
else
{
// Ensure we are dealing with an array.
if (jp.Value.Type != JTokenType.Array)
{
return(args.Log(MessageItem.CreateMessage(jp.Path, MessageType.Error, $"The JSON token is malformed and could not be parsed.")));
}
// Where empty array then update as such.
if (!jp.Value.HasValues)
{
return(UpdateArrayValue(args, pr, entity, (IEnumerable)pr.PropertyExpression.GetValue(entity), (IEnumerable)pr.ComplexTypeReflector.CreateValue()));
}
// Handle array with primitive types.
if (!pr.ComplexTypeReflector.IsItemComplexType)
{
var lo = new List <object>();
foreach (var iv in jp.Value.Values())
{
lo.Add(iv.ToObject(pr.ComplexTypeReflector.ItemType));
}
return(UpdateArrayValue(args, pr, entity, (IEnumerable)pr.PropertyExpression.GetValue(entity), (IEnumerable)pr.ComplexTypeReflector.CreateValue(lo)));
}
// Finally, handle array with complex entity items.
return((pr.Tag == null) ? MergeApplyComplexItems(args, pr, jp, entity) : MergeApplyUniqueKeyItems(args, pr, jp, entity));
}
}
private JArray ArrayUnpatch(JArray right, JObject patch)
{
var toRemove = new List <JProperty>();
var toInsert = new List <JProperty>();
var toModify = new List <JProperty>();
foreach (JProperty op in patch.Properties())
{
if (op.Name == "_t")
{
continue;
}
var value = op.Value as JArray;
if (op.Name.StartsWith("_"))
{
// removed item from original array
if (value != null && value.Count == 3 && (value[2].ToObject <int>() == (int)DiffOperation.Deleted || value[2].ToObject <int>() == (int)DiffOperation.ArrayMove))
{
var newOp = new JProperty(value[1].ToObject <int>().ToString(), op.Value);
if (value[2].ToObject <int>() == (int)DiffOperation.ArrayMove)
{
toInsert.Add(new JProperty(op.Name.Substring(1), new JArray(right[value[1].ToObject <int>()].DeepClone())));
toRemove.Add(newOp);
}
else
{
toInsert.Add(new JProperty(op.Name.Substring(1), new JArray(value[0])));
}
}
else
{
throw new Exception($"Only removal or move can be applied at original array indices. Context: {value}");
}
}
else
{
if (value != null && value.Count == 1)
{
toRemove.Add(op);
}
else
{
toModify.Add(op);
}
}
}
// remove items, in reverse order to avoid sawing our own floor
toRemove.Sort((x, y) => int.Parse(x.Name).CompareTo(int.Parse(y.Name)));
for (int i = toRemove.Count - 1; i >= 0; --i)
{
JProperty op = toRemove[i];
right.RemoveAt(int.Parse(op.Name));
}
// insert items, in reverse order to avoid moving our own floor
toInsert.Sort((x, y) => int.Parse(x.Name).CompareTo(int.Parse(y.Name)));
foreach (var op in toInsert)
{
right.Insert(int.Parse(op.Name), ((JArray)op.Value)[0]);
}
foreach (var op in toModify)
{
JToken p = Unpatch(right[int.Parse(op.Name)], op.Value);
right[int.Parse(op.Name)] = p;
}
return(right);
}
public void ITypedListGetItemProperties()
{
JProperty p1 = new JProperty("Test1", 1);
JProperty p2 = new JProperty("Test2", "Two");
ITypedList l = new JObject(p1, p2);
PropertyDescriptorCollection propertyDescriptors = l.GetItemProperties(null);
Assert.Null(propertyDescriptors);
}
public void IListAdd()
{
var p = new JProperty("TestProperty", null);
IList l = p;
AssertException.Throws<JsonException>(() => { l.Add(null); }, "OpenGamingLibrary.Json.Linq.JProperty cannot have multiple values.");
}
public string DamRequestCreate(string jsonFile)
{
LogManager.DoLogOperation("[DAM Server] Receive Request to create DAM");
DamRestCommand.JsonDamCreate test = DamRestCommand.LoadJson_DamCreate(jsonFile);
/* format json response */
JObject result = new JObject();
JProperty a;
JProperty b;
JProperty c;
/*Calculate EncK*/
byte[] EncK = DamCrypto.EncK(test.damauthkey, test.damdefaultkey, test.damdefaultkeyversion);
/* secret dammac key */
byte[] DAMMACKey = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint iAid = 0x000000;
if (test.aid.Length != 3)
{
a = new JProperty("Enk", Converters.ByteArrayToSimpleHexString(EncK));
result.Add(a);
b = new JProperty("DAMMAC", Converters.ByteArrayToSimpleHexString(EncK));
result.Add(b);
c = new JProperty("status", "aid error");
result.Add(c);
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
iAid = test.aid[2];
iAid += (uint)(test.aid[1] << 8);
iAid += (uint)(test.aid[0] << 16);
/* Calculate DAMMAC */
byte[] dammac = DamCrypto.DAMMAC(
DAMMACKey,
DF_CREATE_DELEGATED_APPLICATION,
iAid, test.damslotno, test.damslotversion, test.quotalimit, test.key_setting1, test.key_setting2,
test.key_setting3, test.aksversion, test.nokeyset, test.maxkeysize, test.rollkey,
test.iso_df_id, test.iso_df_name,
EncK);
c = new JProperty("Result", "ok");
result.Add(c);
/* le proprietaire connait les valeurs en fonction de sa base de données */
/* les valeurs correspondent au DAMMAC crée */
c = new JProperty("damslotno", "0");
result.Add(c);
c = new JProperty("damslotversion", "FF");
result.Add(c);
c = new JProperty("quotalimit", "10");
result.Add(c);
a = new JProperty("Enck", Converters.ByteArrayToSimpleHexString(EncK));
result.Add(a);
b = new JProperty("DAMMAC", Converters.ByteArrayToSimpleHexString(dammac));
result.Add(b);
return(JsonConvert.SerializeObject(result, Formatting.Indented));
}
