/// <summary> /// Persists a compound metadata attribute in the database /// </summary> /// <param name="entity">is an unsaved compound metadata data attribute</param> /// <returns>The saved compound metadata attribute</returns> /// <remarks>The attribute should have at least two other attributes as its member to be considered a compound! Also it should have at least a non empty short name.</remarks> public MetadataCompoundAttribute Create(MetadataCompoundAttribute entity) { Contract.Requires(!string.IsNullOrWhiteSpace(entity.ShortName)); //Contract.Requires(entity.DataType != null && entity.DataType.Id >= 0); //Contract.Requires(entity.Unit != null && entity.Unit.Id >= 0); Contract.Requires(entity.MetadataNestedAttributeUsages != null && entity.MetadataNestedAttributeUsages.Count >= 2); Contract.Ensures(Contract.Result<MetadataCompoundAttribute>() != null && Contract.Result<MetadataCompoundAttribute>().Id >= 0); using (IUnitOfWork uow = this.GetUnitOfWork()) { IRepository<MetadataCompoundAttribute> repo = uow.GetRepository<MetadataCompoundAttribute>(); repo.Put(entity); uow.Commit(); } return (entity); }
private void createMetadataAttribute() { //UnitManager um = new UnitManager(); //Unit km = um.Create("Kilometer", "Km", "This is the Kilometer", "Length", MeasurementSystem.Metric); DataTypeManager dtManager = new DataTypeManager(); DataType dt1 = dtManager.Repo.Get(p => p.Name.Equals("String")).FirstOrDefault(); if (dt1 == null) { dt1 = dtManager.Create("String", "A test String", System.TypeCode.String); } MetadataAttributeManager maManager = new MetadataAttributeManager(); // for unique name checks USE maManager.MetadataAttributeRepo that is searching both simple and compound attribute names var msa1 = maManager.MetadataAttributeRepo.Get(p => p.ShortName.Equals("Simple 1")).FirstOrDefault(); if (msa1 == null) { msa1 = new MetadataSimpleAttribute() { ShortName = "Simple 1", DataType = dt1, }; maManager.Create((MetadataSimpleAttribute)msa1); } var msa2 = maManager.MetadataAttributeRepo.Get(p => p.ShortName.Equals("Simple 2")).FirstOrDefault(); if (msa2 == null) { msa2 = new MetadataSimpleAttribute() { ShortName = "Simple 2", DataType = dt1, }; maManager.Create((MetadataSimpleAttribute)msa2); } MetadataCompoundAttribute mca1 = (MetadataCompoundAttribute)maManager.MetadataAttributeRepo.Get(p => p.ShortName.Equals("Compound 1")).FirstOrDefault(); if (mca1 == null) { mca1 = new MetadataCompoundAttribute() { ShortName = "Compound 1", DataType = dt1, }; MetadataNestedAttributeUsage u1 = new MetadataNestedAttributeUsage() { Label = "First member", Description = "I am a link between Compound 1 and Simple 1", MinCardinality = 0, MaxCardinality = 2, Master = mca1, Member = msa1, }; mca1.MetadataNestedAttributeUsages.Add(u1); MetadataNestedAttributeUsage u2 = new MetadataNestedAttributeUsage() { Label = "Second member", Description = "I am a link between Compound 1 and Simple 2", MinCardinality = 0, MaxCardinality = 2, Master = mca1, Member = msa2, }; mca1.MetadataNestedAttributeUsages.Add(u2); maManager.Create(mca1); } maManager.Delete(msa1); }
private void addMetadataAttributeToMappingFile(MetadataCompoundAttribute compoundAttribute, XmlSchemaElement element, string internalXPath, string externalXPath) { MetadataAttribute attribute; if (metadataAttributeManager.MetadataAttributeRepo != null && metadataAttributeManager.MetadataAttributeRepo.Get().Where(m => m.Name.Equals(GetTypeOfName(element.Name))).Count() > 0) { attribute = metadataAttributeManager.MetadataAttributeRepo.Get().Where(m => m.Name.Equals(GetTypeOfName(element.Name))).First(); } else { attribute = createMetadataAttribute(element); } #region generate MappingRoute addToExportMappingFile(mappingFileInternalToExternal, internalXPath, externalXPath, element.MaxOccurs, element.Name, attribute.Name); addToImportMappingFile(mappingFileExternalToInternal, externalXPath, internalXPath, element.MaxOccurs, element.Name, attribute.Name); #endregion //Debug.WriteLine("SimpleAttribute :"); //Debug.WriteLine("--- internal :" + childInternalXPath); //Debug.WriteLine("--- external :" + childExternalXPath); //Debug.WriteLine("--- sequence :" + element); }
private MetadataCompoundAttribute addMetadataAttributeToMetadataCompoundAttribute(MetadataCompoundAttribute compoundAttribute, XmlSchemaElement element, string internalXPath, string externalXPath) { MetadataAttribute attribute; if (metadataAttributeManager.MetadataAttributeRepo != null && getExistingMetadataAttribute(GetTypeOfName(element.Name)) != null) { attribute = metadataAttributeManager.MetadataAttributeRepo.Get().Where(m => m.Name.Equals(GetTypeOfName(element.Name))).First(); } else { attribute = createMetadataAttribute(element); } if (attribute != null) { int min = 0; if (element.MinOccurs > int.MinValue) { min = Convert.ToInt32(element.MinOccurs); } int max = 0; if (element.MaxOccurs < int.MaxValue) max = Convert.ToInt32(element.MaxOccurs); else max = int.MaxValue; #region choice //if element is a choise XmlDocument extra = new XmlDocument(); //check if element is a choice if (XmlSchemaUtility.IsChoiceType(element)) { extra = XmlDatasetHelper.AddReferenceToXml(new XmlDocument(), "choice", "true", "elementType", @"extra/type"); } #endregion MetadataNestedAttributeUsage u1 = new MetadataNestedAttributeUsage() { Label = element.Name, Description = attribute.Description, MinCardinality = min, MaxCardinality = max, Master = compoundAttribute, Member = attribute }; if (extra.DocumentElement != null) u1.Extra = extra; #region generate MappingRoute addToExportMappingFile(mappingFileInternalToExternal, internalXPath, externalXPath, element.MaxOccurs, element.Name, attribute.Name); addToImportMappingFile(mappingFileExternalToInternal, externalXPath, internalXPath, element.MaxOccurs, element.Name, attribute.Name); #endregion if (compoundAttribute.MetadataNestedAttributeUsages.Where(n => n.Label.Equals(attribute.Name)).Count()==0) compoundAttribute.MetadataNestedAttributeUsages.Add(u1); } return compoundAttribute; }
private MetadataCompoundAttribute addMetadataAttributesToMetadataCompoundAttribute(MetadataCompoundAttribute compoundAttribute, List<XmlSchemaElement> elements, string internalXPath, string externalXPath) { for (int i = 0; i < elements.Count(); i++) { addMetadataAttributeToMetadataCompoundAttribute(compoundAttribute, elements.ElementAt(i), internalXPath, externalXPath); } return compoundAttribute; }
private MetadataCompoundAttribute createMetadataCompoundAttribute(XmlSchemaElement element) { // create a compoundAttribute int i = 0; MetadataCompoundAttribute mca = getExistingMetadataCompoundAttribute(element.Name + "Type"); ;// = metadataAttributeManager.MetadataCompoundAttributeRepo.Get(p => p.Name == element.Name+"Type").FirstOrDefault(); //Debug.WriteLine("createMetadataCompoundAttribute" + i++); DataType dt1 = dataTypeManager.Repo.Get(p => p.Name.ToLower().Equals("string")).FirstOrDefault(); if (dt1 == null) { dt1 = dataTypeManager.Create("string", "A test String", System.TypeCode.String); } if (mca == null) { mca = new MetadataCompoundAttribute { ShortName = GetTypeOfName(element.Name), Name = GetTypeOfName(element.Name), Description = "", DataType = dt1 }; } return mca; }
private MetadataCompoundAttribute createMetadataCompoundAttribute(XmlSchemaComplexType complexType) { // create a compoundAttribute MetadataCompoundAttribute mca = getExistingMetadataCompoundAttribute(complexType.Name);// = metadataAttributeManager.MetadataCompoundAttributeRepo.Get(p => p.Name == complexType.Name).FirstOrDefault(); DataType dt1 = dataTypeManager.Repo.Get(p => p.Name.ToLower().Equals("string")).FirstOrDefault(); if (dt1 == null) { dt1 = dataTypeManager.Create("String", "A test String", System.TypeCode.String); } if (mca == null) { mca = new MetadataCompoundAttribute { ShortName = complexType.Name, Name = complexType.Name, Description = GetDescription(complexType.Annotation), DataType = dt1 }; } return mca; }
private void addUsageFromMetadataCompoundAttributeToPackage(MetadataPackage package, MetadataCompoundAttribute compoundAttribute, XmlSchemaElement element) { if (package.MetadataAttributeUsages.Where(p => p.Label == element.Name).Count() <= 0) { int min = 0; if (element.MinOccurs > int.MinValue) min = Convert.ToInt32(element.MinOccurs); else min = int.MinValue; int max = 0; if (element.MaxOccurs < int.MaxValue) max = Convert.ToInt32(element.MaxOccurs); else max = int.MaxValue; metadataPackageManager.AddMetadataAtributeUsage(package, compoundAttribute, element.Name, GetDescription(element.Annotation), min, max); } }
private MetadataCompoundAttribute addUsageFromMetadataCompoundAttributeToMetadataCompoundAttribute(MetadataCompoundAttribute parent, MetadataCompoundAttribute compoundAttribute, XmlSchemaElement element) { if (parent.MetadataNestedAttributeUsages.Where(p => p.Label == element.Name).Count() <= 0) { //get max int max = Int32.MaxValue; if (element.MaxOccurs < Int32.MaxValue) { max = Convert.ToInt32(element.MaxOccurs); } MetadataNestedAttributeUsage usage = new MetadataNestedAttributeUsage() { Label = element.Name, Description = GetDescription(element.Annotation), MinCardinality = Convert.ToInt32(element.MinOccurs), MaxCardinality = max, Master = parent, Member = compoundAttribute, }; #region choice //if element is a choise XmlDocument extra = new XmlDocument(); //check if element is a choice if (XmlSchemaUtility.IsChoiceType(element)) { extra = XmlDatasetHelper.AddReferenceToXml(new XmlDocument(), "choice", "true", "elementType",@"extra/type"); } if (extra.DocumentElement != null) usage.Extra = extra; #endregion parent.MetadataNestedAttributeUsages.Add(usage); } return parent; }