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); } }