public static dynamic ToData(CdmArgumentDefinition instance, ResolveOptions resOpt, CopyOptions options)
{
dynamic val = null;
if (instance.Value != null)
{
if (instance.Value is string || instance.Value is JValue)
{
val = (string)instance.Value;
}
else if (instance.Value is CdmObject)
{
val = ((CdmObject)instance.Value).CopyData(resOpt, options);
}
else
{
val = instance.Value;
}
}
// skip the argument if just a value
if (string.IsNullOrEmpty(instance.Name))
{
return(val);
}
return(new Argument {
Explanation = instance.Explanation,
Name = instance.Name,
Value = JToken.FromObject(val, JsonSerializationUtil.JsonSerializer)
});
}
public void TestCdmArgumentCollectionAddRange()
{
var trait = GenerateTrait();
trait.ResolvedArguments = true;
var argList = new List <CdmArgumentDefinition>();
var argumentDefinition = new CdmArgumentDefinition(trait.Ctx, null)
{
Name = "Arg1",
Value = 123
};
argList.Add(argumentDefinition);
var valOfArg2 = CdmCollectionHelperFunctions.GenerateManifest("C://Nothing");
argumentDefinition = new CdmArgumentDefinition(trait.Ctx, null)
{
Name = "Arg2",
Value = valOfArg2
};
argList.Add(argumentDefinition);
trait.Arguments.AddRange(argList);
Assert.AreEqual(2, trait.Arguments.Count);
Assert.IsFalse(trait.ResolvedArguments);
Assert.AreEqual("Arg1", trait.Arguments[0].Name);
Assert.AreEqual(123, trait.Arguments[0].Value);
Assert.AreEqual(trait, trait.Arguments[0].Owner);
Assert.AreEqual("Arg2", trait.Arguments[1].Name);
Assert.AreEqual(valOfArg2, trait.Arguments[1].Value);
}
public string GetArgumentValuesAsString(CdmArgumentDefinition args)
{
// clear the string builder
bldr.Clear();
// get the corpus path for each attribute context in the tree
GetArgumentValues(args);
return(bldr.ToString());
}
internal static async Task ProcessAnnotationsFromData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
var multiTraitAnnotations = new List <NameValuePair>();
if (obj.Annotations != null)
{
foreach (var element in obj.Annotations)
{
if (!ShouldAnnotationGoIntoASingleTrait(element.Name))
{
NameValuePair cdmElement = new NameValuePair()
{
Name = element.Name,
Value = element.Value
};
multiTraitAnnotations.Add(cdmElement);
}
else
{
var innerTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, ConvertAnnotationToTrait(element.Name));
innerTrait.Arguments.Add(await ArgumentPersistence.FromData(ctx, element));
traits.Add(innerTrait);
}
}
if (multiTraitAnnotations.Count > 0)
{
var trait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.otherAnnotations", false);
trait.IsFromProperty = false;
var annotationsArgument = new CdmArgumentDefinition(ctx, "annotations")
{
Value = multiTraitAnnotations
};
trait.Arguments.Add(annotationsArgument);
traits.Add(trait);
}
}
if (obj.Traits != null)
{
foreach (var trait in obj.Traits)
{
var trToken = JToken.FromObject(trait);
if (!(trToken is JValue) && trToken["traitGroupReference"] != null)
{
traits.Add(CdmFolder.TraitGroupReferencePersistence.FromData(ctx, trToken));
}
else
{
traits.Add(CdmFolder.TraitReferencePersistence.FromData(ctx, trToken));
}
}
}
}
public static async Task <Annotation> ToData(CdmArgumentDefinition instance, ResolveOptions resOpt, CopyOptions options)
{
if (instance.Value is string)
{
return(new Annotation
{
Name = instance.Name,
Value = instance.Value
});
}
return(null);
}
public void SetParameterValueFromArgument(CdmTraitDefinition trait, CdmArgumentDefinition arg)
{
ResolvedTrait resTrait = this.Get(trait);
if (resTrait?.ParameterValues != null)
{
List <dynamic> av = resTrait.ParameterValues.Values;
dynamic newVal = arg.Value;
// get the value index from the parameter collection given the parameter that this argument is setting
int iParam = resTrait.ParameterValues.IndexOf(arg.GetParameterDef());
av[iParam] = ParameterValue.FetchReplacementValue(this.ResOpt, av[iParam], newVal, true);
resTrait.ParameterValues.WasSet[iParam] = true;
}
}
public void TestCdmArgumentCollectionInsert()
{
var trait = GenerateTrait();
var toInsert = new CdmArgumentDefinition(trait.Ctx, null);
var arg1 = trait.Arguments.Add("arg1");
var arg2 = trait.Arguments.Add("arg2");
trait.ResolvedArguments = true;
trait.Arguments.Insert(1, toInsert);
Assert.AreEqual(3, trait.Arguments.Count);
Assert.IsFalse(trait.ResolvedArguments);
Assert.AreEqual(arg1, trait.Arguments[0]);
Assert.AreEqual(toInsert, trait.Arguments[1]);
Assert.AreEqual(arg2, trait.Arguments[2]);
Assert.AreEqual(trait, trait.Arguments[1].Owner);
}
private void GetArgumentValuesAsString(CdmArgumentDefinition args)
{
string paramName = args.ResolvedParameter?.Name;
string paramDefaultValue = args.ResolvedParameter?.DefaultValue;
if (!string.IsNullOrWhiteSpace(paramName) || !string.IsNullOrWhiteSpace(paramDefaultValue))
{
bldr.AppendLine($" [Parameter (Name / DefaultValue): {paramName} / {paramDefaultValue}]");
}
if (args.Value is string)
{
string argsValue = args.Value;
if (!string.IsNullOrWhiteSpace(argsValue))
{
bldr.AppendLine($" [Argument Value: {argsValue}]");
}
}
else if (args.Value?.SimpleNamedReference == true)
{
string argsValue = args.Value.NamedReference;
if (!string.IsNullOrWhiteSpace(argsValue))
{
bldr.AppendLine($" [Argument Value: {argsValue}]");
}
}
else if (args.Value?.ExplicitReference.ObjectType == CdmObjectType.ConstantEntityDef)
{
var constEnt = (CdmConstantEntityDefinition)((CdmObjectReferenceBase)args.Value).ExplicitReference;
if (constEnt != null)
{
List <CdmEntityDefinition> refs = new List <CdmEntityDefinition>();
foreach (List <string> val in constEnt.ConstantValues)
{
bldr.AppendLine($" [Argument Value: {string.Join(',', val)}]");
}
}
}
}
public void SetParameterValueFromArgument(CdmTraitDefinition trait, CdmArgumentDefinition arg)
{
ResolvedTrait resTrait = this.Get(trait);
if (resTrait?.ParameterValues != null)
{
List <dynamic> av = resTrait.ParameterValues.Values;
dynamic newVal = arg.Value;
// get the value index from the parameter collection given the parameter that this argument is setting
var paramDef = arg.GetParameterDef();
if (paramDef != null)
{
resTrait.ParameterValues.SetParameterValue(this.ResOpt, paramDef.GetName(), newVal);
}
else
{
// debug
paramDef = arg.GetParameterDef();
}
}
}
internal static async Task ProcessAnnotationsFromData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
var multiTraitAnnotations = new List <Annotation>();
if (obj.Annotations != null)
{
foreach (var element in obj.Annotations)
{
if (!ShouldAnnotationGoIntoASingleTrait(element.Name))
{
multiTraitAnnotations.Add(element);
}
else
{
var innerTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, ConvertAnnotationToTrait(element.Name));
innerTrait.Arguments.Add(await ArgumentPersistence.FromData(ctx, element));
traits.Add(innerTrait);
}
}
var trait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.otherAnnotations", false);
trait.IsFromProperty = true;
var annotationsArgument = new CdmArgumentDefinition(ctx, "annotations")
{
Value = multiTraitAnnotations
};
trait.Arguments.Add(annotationsArgument);
traits.Add(trait);
}
if (obj.Traits != null)
{
foreach (var trait in obj.Traits)
{
var traitInstance = CdmFolder.TraitReferencePersistence.FromData(ctx, JToken.FromObject(trait));
traits.Add(traitInstance);
}
}
}
public void TestCdmArgumentCollectionFetchValueOrOnlyValue()
{
var trait = GenerateTrait();
trait.ResolvedArguments = true;
trait.Arguments.Add(null, "ValueOfTrait");
var value = trait.Arguments.FetchValue("NameOfTrait");
// This is what is needed by current code.
Assert.AreEqual("ValueOfTrait", value);
var argumentDefinition = new CdmArgumentDefinition(trait.Ctx, null);
trait.ResolvedArguments = true;
trait.Arguments.Add(argumentDefinition);
trait.ResolvedArguments = true;
trait.Arguments.Add("TraitName", "Value of a named trait");
value = trait.Arguments.FetchValue("TraitName");
Assert.AreEqual("Value of a named trait", value);
}
public void TestCdmArgumentCollectionAdd()
{
var trait = GenerateTrait();
var argumentDefinition = new CdmArgumentDefinition(trait.Ctx, null);
trait.ResolvedArguments = true;
Assert.AreEqual(0, trait.Arguments.Count);
var addedArgument = trait.Arguments.Add(argumentDefinition);
Assert.AreEqual(argumentDefinition, addedArgument);
Assert.AreEqual(1, trait.Arguments.Count);
Assert.AreEqual(argumentDefinition, trait.Arguments[0]);
Assert.IsFalse(trait.ResolvedArguments);
Assert.AreEqual(trait, trait.Arguments[0].Owner);
trait.ResolvedArguments = true;
trait.Arguments.Add("nameOfTrait", "ValueOfTrait");
Assert.AreEqual(2, trait.Arguments.Count);
Assert.AreEqual("nameOfTrait", trait.Arguments[1].Name);
Assert.AreEqual("ValueOfTrait", trait.Arguments[1].Value);
Assert.AreEqual(trait, trait.Arguments[1].Owner);
}
/// <summary>
/// Processes extensions from an object which was obtained from a "model.json" file.
/// From every extension found, it's value (name, value) is added to traitRefSet,
/// and it's definition (name, type) is added to extensionTraitDefList.
/// </summary>
/// <param name="ctx"> The context </param>
/// <param name="sourceObject"> The object obtained from "model.json" file.</param>
/// <param name="traitRefSet"> The list of extensions found, in the form of (name & value).</param>
/// <param name="extensionTraitDefList"> The list of definitions. For each extension, it's definition is added to this list (name & type).</param>
/// <param name="localExtensionTraitDefList"> Same as extensionTraitDefList but limited to extensions inside one document.</param>
public static void ProcessExtensionFromJson(
CdmCorpusContext ctx,
MetadataObject sourceObject,
CdmTraitCollection traitRefSet,
List <CdmTraitDefinition> extensionTraitDefList,
List <CdmTraitDefinition> localExtensionTraitDefList = null)
{
var extensions = sourceObject.ExtensionFields;
foreach (JProperty extensionAsJProperty in extensions.Children())
{
string traitName = AddExtensionTraitNamePrefix(extensionAsJProperty.Name);
CdmTraitDefinition extensionTraitDef = extensionTraitDefList.Find((CdmTraitDefinition trait) => trait.TraitName == traitName);
bool traitExists = extensionTraitDef != null;
if (!traitExists)
{
extensionTraitDef = ctx.Corpus.MakeObject <CdmTraitDefinition>(CdmObjectType.TraitDef, traitName);
extensionTraitDef.ExtendsTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "is.extension", true);
}
CdmTraitReference extensionTraitRef = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, traitName);
var extensionValue = extensionAsJProperty.Value;
var extensionType = extensionValue.Type;
var shouldLookIntoProperties = extensionType == JTokenType.Object;
if (shouldLookIntoProperties)
{
var extensionValueAsJObject = extensionValue as JObject;
// extensionProperty.Name is here the equivalent of extensionProperty from TS project
foreach (JProperty extensionProperty in extensionValueAsJObject.Children())
{
// for every extensionProperty will have to save the (name, value) pair into extensionArgument,
// which will be saved in extensionTraitRef (the entity that will contain the data)
// (name, type) will be saved in extensionParameter,
// which will be saved in extensionTraitDef (the definition of the data, that can be saved in a schema file)
JToken extensionPropertyValue = extensionProperty.Value;
if (extensionPropertyValue == null)
{
continue;
}
CdmArgumentDefinition extensionArgument = ctx.Corpus.MakeObject <CdmArgumentDefinition>(
CdmObjectType.ArgumentDef,
extensionProperty.Name
);
CdmParameterDefinition extensionParameter = extensionTraitDef.Parameters.AllItems.Find(
(CdmParameterDefinition parameter) => parameter.Name == extensionProperty.Name);
bool parameterExists = extensionParameter != null;
if (!parameterExists)
{
extensionParameter = ctx.Corpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, extensionProperty.Name);
extensionParameter.DataTypeRef = ctx.Corpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef,
ConvertJTokenTypeToExpectedString(extensionPropertyValue.Type),
true);
}
if (extensionPropertyValue is JValue extensionPropertyValueAsJValue)
{
extensionArgument.Value = extensionPropertyValueAsJValue.Value;
}
else
{
extensionArgument.Value = extensionPropertyValue;
}
extensionTraitRef.Arguments.Add(extensionArgument);
if (!parameterExists)
{
extensionTraitDef.Parameters.Add(extensionParameter);
}
}
}
else
{
CdmArgumentDefinition extensionArgument = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, traitName);
CdmParameterDefinition extensionParameter = extensionTraitDef.Parameters.AllItems.Find((CdmParameterDefinition parameter) => parameter.Name == traitName);
bool parameterExists = extensionParameter != null;
if (!parameterExists)
{
extensionParameter = ctx.Corpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, traitName);
extensionParameter.DataTypeRef = ctx.Corpus.MakeObject <CdmDataTypeReference>(
CdmObjectType.DataTypeRef,
ConvertJTokenTypeToExpectedString(extensionType),
true);
}
if (extensionValue is JValue extensionValuePrimite)
{
extensionArgument.Value = extensionValuePrimite.Value;
}
else
{
extensionArgument.Value = extensionValue;
}
extensionTraitRef.Arguments.Add(extensionArgument);
if (!parameterExists)
{
extensionTraitDef.Parameters.Add(extensionParameter);
}
}
if (!traitExists)
{
extensionTraitDefList.Add(extensionTraitDef);
}
if (localExtensionTraitDefList != null)
{
localExtensionTraitDefList.Add(extensionTraitDef);
}
traitRefSet.Add(extensionTraitRef);
}
}
