public static async Task <CdmLocalEntityDeclarationDefinition> FromData(CdmCorpusContext ctx, CdmFolderDefinition documentFolder, LocalEntity obj, CdmCollection <CdmTraitDefinition> extensionTraitDefList)
        {
            var localEntity = ctx.Corpus.MakeObject <CdmLocalEntityDeclarationDefinition>(CdmObjectType.LocalEntityDeclarationDef, obj.Name);

            var entityDoc = await DocumentPersistence.FromData(ctx, obj, extensionTraitDefList);

            if (entityDoc == null)
            {
                Logger.Error(nameof(LocalEntityDeclarationPersistence), ctx, "There was an error while trying to fetch the entity doc from local entity declaration persistence.");
                return(null);
            }

            documentFolder.Documents.Add(entityDoc);

            // Entity schema path is the path to the doc containing the entity definition.
            localEntity.EntityPath  = ctx.Corpus.Storage.CreateRelativeCorpusPath($"{entityDoc.AtCorpusPath}/{obj.Name}", entityDoc);
            localEntity.Explanation = obj.Description;
            localEntity.LastChildFileModifiedTime = obj.LastChildFileModifiedTime;
            localEntity.LastFileModifiedTime      = obj.LastFileModifiedTime;
            localEntity.LastFileStatusCheckTime   = obj.LastFileStatusCheckTime;

            if (obj.IsHidden == true)
            {
                var isHiddenTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
                isHiddenTrait.IsFromProperty = true;
                localEntity.ExhibitsTraits.Add(isHiddenTrait);
            }

            // Add traits for schema entity info.
            if (obj.Schemas != null)
            {
                var t2pm = new TraitToPropertyMap(localEntity);
                t2pm.UpdatePropertyValue("cdmSchemas", obj.Schemas);
            }

            // Data partitions are part of the local entity, add them here.
            if (obj.Partitions != null)
            {
                foreach (var element in obj.Partitions)
                {
                    var cdmPartition = await DataPartitionPersistence.FromData(ctx, element, extensionTraitDefList);

                    if (cdmPartition != null)
                    {
                        localEntity.DataPartitions.Add(cdmPartition);
                    }
                    else
                    {
                        Logger.Error(nameof(LocalEntityDeclarationPersistence), ctx, "There was an error while trying to fetch the entity doc from local entity declaration persistence.");
                        return(null);
                    }
                }
            }

            return(localEntity);
        }
        public static async Task <CdmLocalEntityDeclarationDefinition> FromData(CdmCorpusContext ctx, CdmFolderDefinition documentFolder, LocalEntity obj, List <CdmTraitDefinition> extensionTraitDefList, CdmManifestDefinition manifest)
        {
            var localEntity = ctx.Corpus.MakeObject <CdmLocalEntityDeclarationDefinition>(CdmObjectType.LocalEntityDeclarationDef, obj.Name);

            var localExtensionTraitDefList = new List <CdmTraitDefinition>();

            var entityDoc = await DocumentPersistence.FromData(ctx, obj, extensionTraitDefList, localExtensionTraitDefList);

            documentFolder.Documents.Add(entityDoc);

            // Entity schema path is the path to the doc containing the entity definition.
            localEntity.EntityPath  = ctx.Corpus.Storage.CreateRelativeCorpusPath($"{entityDoc.AtCorpusPath}/{obj.Name}", manifest);
            localEntity.Explanation = obj.Description;
            localEntity.LastChildFileModifiedTime = obj.LastChildFileModifiedTime;
            localEntity.LastFileModifiedTime      = obj.LastFileModifiedTime;
            localEntity.LastFileStatusCheckTime   = obj.LastFileStatusCheckTime;

            if (obj.IsHidden == true)
            {
                var isHiddenTrait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
                isHiddenTrait.IsFromProperty = true;
                localEntity.ExhibitsTraits.Add(isHiddenTrait);
            }

            // Add traits for schema entity info.
            if (obj.Schemas != null)
            {
                var t2pm = new TraitToPropertyMap(localEntity);
                t2pm.UpdatePropertyValue("cdmSchemas", obj.Schemas);
            }

            // Data partitions are part of the local entity, add them here.
            if (obj.Partitions != null)
            {
                foreach (var element in obj.Partitions)
                {
                    var cdmPartition = await DataPartitionPersistence.FromData(ctx, element, extensionTraitDefList, localExtensionTraitDefList, documentFolder);

                    if (cdmPartition != null)
                    {
                        localEntity.DataPartitions.Add(cdmPartition);
                    }
                    else
                    {
                        Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistModelJsonDocConversionError);
                        return(null);
                    }
                }
            }

            List <CdmImport> importDocs = await ExtensionHelper.StandardImportDetection(ctx, extensionTraitDefList, localExtensionTraitDefList);

            ExtensionHelper.AddImportDocsToManifest(ctx, importDocs, entityDoc);

            return(localEntity);
        }
예제 #3
0
        public static CdmTypeAttributeDefinition FromData(CdmCorpusContext ctx, JToken obj, string entityName = null)
        {
            if (obj == null)
            {
                return(null);
            }

            var typeAttribute = ctx.Corpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, (string)obj["name"]);

            typeAttribute.Purpose  = PurposeReferencePersistence.FromData(ctx, obj["purpose"]);
            typeAttribute.DataType = DataTypeReferencePersistence.FromData(ctx, obj["dataType"]);

            typeAttribute.Cardinality = Utils.CardinalitySettingsFromData(obj["cardinality"], typeAttribute);

            typeAttribute.AttributeContext = AttributeContextReferencePersistence.FromData(ctx, obj["attributeContext"]);
            Utils.AddListToCdmCollection(typeAttribute.AppliedTraits, Utils.CreateTraitReferenceList(ctx, obj["appliedTraits"]));
            typeAttribute.ResolutionGuidance = AttributeResolutionGuidancePersistence.FromData(ctx, obj["resolutionGuidance"]);

            if (obj["isPrimaryKey"] != null && (bool)obj["isPrimaryKey"] && entityName != null)
            {
                TraitToPropertyMap t2pMap = new TraitToPropertyMap(typeAttribute);
                t2pMap.UpdatePropertyValue("isPrimaryKey", entityName + "/(resolvedAttributes)/" + typeAttribute.Name);
            }

            typeAttribute.Explanation            = Utils.PropertyFromDataToString(obj["explanation"]);
            typeAttribute.Description            = Utils.PropertyFromDataToString(obj["description"]);
            typeAttribute.IsReadOnly             = Utils.PropertyFromDataToBool(obj["isReadOnly"]);
            typeAttribute.IsNullable             = Utils.PropertyFromDataToBool(obj["isNullable"]);
            typeAttribute.SourceName             = Utils.PropertyFromDataToString(obj["sourceName"]);
            typeAttribute.SourceOrdering         = Utils.PropertyFromDataToInt(obj["sourceOrdering"]);
            typeAttribute.DisplayName            = Utils.PropertyFromDataToString(obj["displayName"]);
            typeAttribute.ValueConstrainedToList = Utils.PropertyFromDataToBool(obj["valueConstrainedToList"]);
            typeAttribute.MaximumLength          = Utils.PropertyFromDataToInt(obj["maximumLength"]);
            typeAttribute.MaximumValue           = Utils.PropertyFromDataToString(obj["maximumValue"]);
            typeAttribute.MinimumValue           = Utils.PropertyFromDataToString(obj["minimumValue"]);
            typeAttribute.DefaultValue           = obj["defaultValue"];
            typeAttribute.Projection             = ProjectionPersistence.FromData(ctx, obj["projection"]);

            var dataFormat = Utils.PropertyFromDataToString(obj["dataFormat"]);

            if (dataFormat != null)
            {
                bool success = Enum.TryParse(dataFormat, true, out CdmDataFormat cdmDataFormat);
                if (success)
                {
                    typeAttribute.DataFormat = cdmDataFormat;
                }
                else
                {
                    Logger.Warning(ctx, Tag, nameof(FromData), null, CdmLogCode.WarnPersistEnumNotFound, dataFormat);
                }
            }

            return(typeAttribute);
        }
        public void TestUpdateAndFetchListLookup()
        {
            var corpus             = new CdmCorpusDefinition();
            var cdmAttribute       = new CdmTypeAttributeDefinition(corpus.Ctx, "SomeAttribute");
            var traitToPropertyMap = new TraitToPropertyMap(cdmAttribute);

            var constantValues = new JArray(
                new JObject(
                    new JProperty("languageTag", "en"),
                    new JProperty("displayText", "Fax")));

            traitToPropertyMap.UpdatePropertyValue("defaultValue", constantValues);
            List <dynamic> result = traitToPropertyMap.FetchPropertyValue("defaultValue");

            Assert.AreEqual(1, result.Count);

            var property = result[0] as Dictionary <string, string>;

            Assert.AreEqual("en", property["languageTag"]);
            Assert.AreEqual("Fax", property["displayText"]);
            Assert.IsNull(property["attributeValue"]);
            Assert.IsNull(property["displayOrder"]);
        }
예제 #5
0
        public static CdmTypeAttributeDefinition FromData(CdmCorpusContext ctx, JToken obj, string entityName = null)
        {
            if (obj == null)
            {
                return(null);
            }

            var typeAttribute = ctx.Corpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, (string)obj["name"]);

            typeAttribute.Purpose  = PurposeReferencePersistence.FromData(ctx, obj["purpose"]);
            typeAttribute.DataType = DataTypeReferencePersistence.FromData(ctx, obj["dataType"]);
            if (obj["cardinality"] != null)
            {
                string minCardinality = null;
                if (obj["cardinality"]["minimum"] != null)
                {
                    minCardinality = (string)obj["cardinality"]["minimum"];
                }

                string maxCardinality = null;
                if (obj["cardinality"]["maximum"] != null)
                {
                    maxCardinality = (string)obj["cardinality"]["maximum"];
                }

                if (string.IsNullOrWhiteSpace(minCardinality) || string.IsNullOrWhiteSpace(maxCardinality))
                {
                    Logger.Error(nameof(TypeAttributePersistence), ctx, $"Both minimum and maximum are required for the Cardinality property.", nameof(FromData));
                }

                if (!CardinalitySettings.IsMinimumValid(minCardinality))
                {
                    Logger.Error(nameof(TypeAttributePersistence), ctx, $"Invalid minimum cardinality {minCardinality}.", nameof(FromData));
                }

                if (!CardinalitySettings.IsMaximumValid(maxCardinality))
                {
                    Logger.Error(nameof(TypeAttributePersistence), ctx, $"Invalid maximum cardinality {maxCardinality}.", nameof(FromData));
                }

                if (!string.IsNullOrWhiteSpace(minCardinality) &&
                    !string.IsNullOrWhiteSpace(maxCardinality) &&
                    CardinalitySettings.IsMinimumValid(minCardinality) &&
                    CardinalitySettings.IsMinimumValid(maxCardinality))
                {
                    typeAttribute.Cardinality = new CardinalitySettings(typeAttribute)
                    {
                        Minimum = minCardinality,
                        Maximum = maxCardinality
                    };
                }
            }
            typeAttribute.AttributeContext = AttributeContextReferencePersistence.FromData(ctx, obj["attributeContext"]);
            Utils.AddListToCdmCollection(typeAttribute.AppliedTraits, Utils.CreateTraitReferenceList(ctx, obj["appliedTraits"]));
            typeAttribute.ResolutionGuidance = AttributeResolutionGuidancePersistence.FromData(ctx, obj["resolutionGuidance"]);

            if (obj["isPrimaryKey"] != null && (bool)obj["isPrimaryKey"] && entityName != null)
            {
                TraitToPropertyMap t2pMap = new TraitToPropertyMap(typeAttribute);
                t2pMap.UpdatePropertyValue("isPrimaryKey", entityName + "/(resolvedAttributes)/" + typeAttribute.Name);
            }

            typeAttribute.Explanation            = Utils.PropertyFromDataToString(obj["explanation"]);
            typeAttribute.Description            = Utils.PropertyFromDataToString(obj["description"]);
            typeAttribute.IsReadOnly             = Utils.PropertyFromDataToBool(obj["isReadOnly"]);
            typeAttribute.IsNullable             = Utils.PropertyFromDataToBool(obj["isNullable"]);
            typeAttribute.SourceName             = Utils.PropertyFromDataToString(obj["sourceName"]);
            typeAttribute.SourceOrdering         = Utils.PropertyFromDataToInt(obj["sourceOrdering"]);
            typeAttribute.DisplayName            = Utils.PropertyFromDataToString(obj["displayName"]);
            typeAttribute.ValueConstrainedToList = Utils.PropertyFromDataToBool(obj["valueConstrainedToList"]);
            typeAttribute.MaximumLength          = Utils.PropertyFromDataToInt(obj["maximumLength"]);
            typeAttribute.MaximumValue           = Utils.PropertyFromDataToString(obj["maximumValue"]);
            typeAttribute.MinimumValue           = Utils.PropertyFromDataToString(obj["minimumValue"]);
            typeAttribute.DefaultValue           = obj["defaultValue"];
            typeAttribute.Projection             = ProjectionPersistence.FromData(ctx, obj["projection"]);

            var dataFormat = Utils.PropertyFromDataToString(obj["dataFormat"]);

            if (dataFormat != null)
            {
                bool success = Enum.TryParse(dataFormat, true, out CdmDataFormat cdmDataFormat);
                if (success)
                {
                    typeAttribute.DataFormat = cdmDataFormat;
                }
                else
                {
                    Logger.Warning(nameof(TypeAttributePersistence), ctx, $"Couldn't find an enum value for {dataFormat}.", nameof(FromData));
                }
            }

            return(typeAttribute);
        }
예제 #6
0
        public static CdmTypeAttributeDefinition FromData(CdmCorpusContext ctx, DataColumn obj, string entityName = null)
        {
            var typeAttribute = ctx.Corpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, obj.Name);
            var properties    = obj.OriginDataTypeName.Properties;

            typeAttribute.DataFormat = Utils.SymsDataTypeToCdmDataFormat(obj.OriginDataTypeName);

            if (obj.OriginDataTypeName.Scale != 0 || obj.OriginDataTypeName.Precision != 0)
            {
                var numericTraits = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.dataFormat.numeric.shaped", true);

                var scaleTraitsArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "scale");
                scaleTraitsArg.Value = obj.OriginDataTypeName.Scale;
                numericTraits.Arguments.Add(scaleTraitsArg);

                var precisionTraitsArg = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "scale");
                precisionTraitsArg.Value = obj.OriginDataTypeName.Scale;
                numericTraits.Arguments.Add(precisionTraitsArg);
            }

            if (properties != null)
            {
                if (properties.ContainsKey("cdm:purpose"))
                {
                    typeAttribute.Purpose = properties["cdm:purpose"].ToObject <CdmPurposeReference>();
                }
                if (properties.ContainsKey("cdm:dataType"))
                {
                    typeAttribute.DataType = properties["cdm:dataType"].ToObject <CdmDataTypeReference> ();
                }
                if (properties.ContainsKey("cdm:cardinality"))
                {
                    string minCardinality = null;
                    if (properties["cdm:minimum"] != null)
                    {
                        minCardinality = properties["cdm:minimum"].ToObject <string>();
                    }

                    string maxCardinality = null;
                    if (properties["cdm:maximum"] != null)
                    {
                        maxCardinality = properties["cdm:maximum"].ToObject <string>();
                    }

                    if (string.IsNullOrWhiteSpace(minCardinality) || string.IsNullOrWhiteSpace(maxCardinality))
                    {
                        Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrPersistCardinalityPropMissing);
                    }

                    if (!CardinalitySettings.IsMinimumValid(minCardinality))
                    {
                        Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrValdnInvalidMinCardinality, minCardinality);
                    }

                    if (!CardinalitySettings.IsMaximumValid(maxCardinality))
                    {
                        Logger.Error((ResolveContext)ctx, Tag, nameof(FromData), null, CdmLogCode.ErrValdnInvalidMaxCardinality, maxCardinality);
                    }

                    if (!string.IsNullOrWhiteSpace(minCardinality) && !string.IsNullOrWhiteSpace(maxCardinality) &&
                        CardinalitySettings.IsMinimumValid(minCardinality) && CardinalitySettings.IsMinimumValid(maxCardinality))
                    {
                        typeAttribute.Cardinality = new CardinalitySettings(typeAttribute)
                        {
                            Minimum = minCardinality,
                            Maximum = maxCardinality
                        };
                    }
                }
                if (properties.ContainsKey("cdm:traits"))
                {
                    Utils.AddListToCdmCollection(typeAttribute.AppliedTraits, Utils.CreateTraitReferenceList(ctx, properties["cdm:traits"]));
                }
                if (properties.ContainsKey("cdm:isPrimaryKey") &&
                    properties["cdm:isPrimaryKey"].ToObject <bool>())
                {
                    TraitToPropertyMap t2pMap = new TraitToPropertyMap(typeAttribute);
                    t2pMap.UpdatePropertyValue("isPrimaryKey", entityName + "/(resolvedAttributes)/" + typeAttribute.Name);
                }
                if (properties.ContainsKey("cdm:isReadOnly"))
                {
                    typeAttribute.IsReadOnly = properties["cdm:isReadOnly"].ToObject <bool>();
                }
                if (properties.ContainsKey("cdm:sourceName"))
                {
                    typeAttribute.SourceName = properties["cdm:sourceName"].ToObject <string>();
                }
                if (properties.ContainsKey("cdm:sourceOrdering"))
                {
                    typeAttribute.SourceOrdering = properties["cdm:sourceOrdering"].ToObject <int>();
                }
                if (properties.ContainsKey("cdm:valueConstrainedToList"))
                {
                    typeAttribute.ValueConstrainedToList = properties["cdm:valueConstrainedToList"].ToObject <bool>();
                }
                if (properties.ContainsKey("cdm:maximumLength"))
                {
                    typeAttribute.MaximumLength = properties["cdm:maximumLength"].ToObject <int>();
                }
                if (properties.ContainsKey("cdm:maximumValue"))
                {
                    typeAttribute.MaximumValue = properties["cdm:maximumValue"].ToObject <string>();
                }
                if (properties.ContainsKey("cdm:minimumValue"))
                {
                    typeAttribute.MinimumValue = properties["cdm:minimumValue"].ToObject <string>();
                }
                if (properties.ContainsKey("cdm:defaultValue"))
                {
                    typeAttribute.DefaultValue = properties["cdm:defaultValue"];
                }
            }

            return(typeAttribute);
        }