internal EntityTypeMapping Clone(EntitySetMapping newEntitySetMapping) { // here we clone the entity type mapping, instead of re-parenting it // this works around an XML editor bug where re-parenting an element causes asserts // first create the new XElement var tempDoc = XDocument.Parse(XElement.ToString(SaveOptions.None), LoadOptions.None); var newetmXElement = tempDoc.Root; newetmXElement.Remove(); // format the XML we just parsed Utils.FormatXML(newetmXElement, newEntitySetMapping.GetIndentLevel() + 1); // create the EntityTypeMapping & hook in it's xml. var newetm = new EntityTypeMapping(newEntitySetMapping, newetmXElement); newetm.AddXElementToParent(newetmXElement); // parse & Resolve the new EntityTypeMapping newetm.Parse(new HashSet <XName>()); XmlModelHelper.NormalizeAndResolve(newetm); // add it to new EntitySetMapping newEntitySetMapping.AddEntityTypeMapping(newetm); return(newetm); }
internal override bool ParseSingleElement(ICollection <XName> unprocessedElements, XElement elem) { if (elem.Name.LocalName == EntitySetMapping.ElementName) { var esm = new EntitySetMapping(this, elem); _entitySetMappings.Add(esm); esm.Parse(unprocessedElements); } else if (elem.Name.LocalName == AssociationSetMapping.ElementName) { var asm = new AssociationSetMapping(this, elem); _associationSetMappings.Add(asm); asm.Parse(unprocessedElements); } else if (elem.Name.LocalName == FunctionImportMapping.ElementName) { var fim = new FunctionImportMapping(this, elem); _functionImportMappings.Add(fim); fim.Parse(unprocessedElements); } else { return(base.ParseSingleElement(unprocessedElements, elem)); } return(true); }
protected override void InvokeInternal(CommandProcessorContext cpc) { // if don't have an ECM yet, go create one if (_entityContainerMapping == null) { var cmd = new CreateEntityContainerMappingCommand(_entitySet.Artifact); CommandProcessor.InvokeSingleCommand(cpc, cmd); _entityContainerMapping = cmd.EntityContainerMapping; } Debug.Assert(_entityContainerMapping != null, "_entityContainerMapping should not be null"); if (_entityContainerMapping == null) { throw new CannotLocateParentItemException(); } // create the ESM var esm = new EntitySetMapping(_entityContainerMapping, null); esm.Name.SetRefName(_entitySet); _entityContainerMapping.AddEntitySetMapping(esm); XmlModelHelper.NormalizeAndResolve(esm); _created = esm; }
/// <summary> /// Creates an EntityTypeMapping in the passed in EntitySetMapping, for the passed in type and kind. /// </summary> /// <param name="entitySetMapping">If this is null, then an EntitySetMapping will be created.</param> /// <param name="entityType">This must be a valid EntityType from the C-Model.</param> /// <param name="kind">Which kind of ETM to create.</param> internal CreateEntityTypeMappingCommand( EntitySetMapping entitySetMapping, ConceptualEntityType entityType, EntityTypeMappingKind kind) { CommandValidation.ValidateEntitySetMapping(entitySetMapping); CommandValidation.ValidateConceptualEntityType(entityType); _entitySetMapping = entitySetMapping; _entityType = entityType; _kind = kind; }
internal void AddEntitySetMapping(EntitySetMapping esm) { _entitySetMappings.Add(esm); }
internal EnforceEntitySetMappingRules(CommandProcessorContext cpc, EntitySetMapping entitySetMapping) { _cpc = cpc; _entitySetMapping = entitySetMapping; }
internal static void AddRule(CommandProcessorContext cpc, EntitySetMapping element) { if (element != null) { IIntegrityCheck check = new EnforceEntitySetMappingRules(cpc, element); cpc.AddIntegrityCheck(check); } }
internal EntityTypeMapping Clone(EntitySetMapping newEntitySetMapping) { // here we clone the entity type mapping, instead of re-parenting it // this works around an XML editor bug where re-parenting an element causes asserts // first create the new XElement var tempDoc = XDocument.Parse(XElement.ToString(SaveOptions.None), LoadOptions.None); var newetmXElement = tempDoc.Root; newetmXElement.Remove(); // format the XML we just parsed Utils.FormatXML(newetmXElement, newEntitySetMapping.GetIndentLevel() + 1); // create the EntityTypeMapping & hook in it's xml. var newetm = new EntityTypeMapping(newEntitySetMapping, newetmXElement); newetm.AddXElementToParent(newetmXElement); // parse & Resolve the new EntityTypeMapping newetm.Parse(new HashSet<XName>()); XmlModelHelper.NormalizeAndResolve(newetm); // add it to new EntitySetMapping newEntitySetMapping.AddEntityTypeMapping(newetm); return newetm; }
internal static void ValidateEntitySetMapping(EntitySetMapping esm) { ValidateEFElement(esm); Debug.Assert(esm.Name.Target != null, "The passed in EntitySetMapping does not reference a known EntitySet"); }
protected override void InvokeInternal(CommandProcessorContext cpc) { // make sure that there isn't an ETM of this kind already var entityTypeMapping = ModelHelper.FindEntityTypeMapping(cpc, _entityType, _kind, false); Debug.Assert(entityTypeMapping == null, "We are calling CreateEntityTypeMappingCommand and there is already one of this Kind"); if (entityTypeMapping != null) { _created = entityTypeMapping; return; } // see if we can get the EntitySetMapping for our entity (if we weren't passed it) if (_entitySetMapping == null) { var ces = _entityType.EntitySet as ConceptualEntitySet; Debug.Assert(ces != null, "_entityType.EntitySet should be a ConceptualEntitySet"); // find the EntitySetMapping for this type (V1 assumption is that there is only ESM per ES) EntitySetMapping esm = null; foreach (var depMapping in ces.GetAntiDependenciesOfType<EntitySetMapping>()) { esm = depMapping; break; } _entitySetMapping = esm; } // if we still don't have an ESM, create one if (_entitySetMapping == null) { var cmd = new CreateEntitySetMappingCommand( _entityType.Artifact.MappingModel().FirstEntityContainerMapping, _entityType.EntitySet as ConceptualEntitySet); CommandProcessor.InvokeSingleCommand(cpc, cmd); _entitySetMapping = cmd.EntitySetMapping; } Debug.Assert( _entitySetMapping != null, "_entitySetMapping should not be null - we have been unable to find or create an EntitySetMapping"); // create the ETM var etm = new EntityTypeMapping(_entitySetMapping, null, _kind); etm.TypeName.SetRefName(_entityType); _entitySetMapping.AddEntityTypeMapping(etm); XmlModelHelper.NormalizeAndResolve(etm); _created = etm; }
/// <summary> /// Creates a new EntityTypeMapping in the existing EntitySetMapping /// based on another EntityTypeMapping (etmToClone) in a different artifact. /// All the other parameters are presumed to already exist in the same artifact /// as the EntitySetMapping. /// </summary> internal static EntityTypeMapping CloneEntityTypeMapping( CommandProcessorContext cpc, EntityTypeMapping etmToClone, EntitySetMapping existingEntitySetMapping, ConceptualEntityType existingEntityType, EntityTypeMappingKind kind) { var createETM = new CreateEntityTypeMappingCommand(existingEntitySetMapping, existingEntityType, kind); var cp = new CommandProcessor(cpc, createETM); cp.Invoke(); var etm = createETM.EntityTypeMapping; foreach (var mappingFragment in etmToClone.MappingFragments()) { var sesToClone = mappingFragment.StoreEntitySet.Target as StorageEntitySet; var ses = existingEntitySetMapping.EntityContainerMapping.Artifact. StorageModel().FirstEntityContainer.GetFirstNamedChildByLocalName(sesToClone.LocalName.Value) as StorageEntitySet; CreateMappingFragmentCommand.CloneMappingFragment(cpc, mappingFragment, etm, ses); } return etm; }
/// <summary> /// Creates a new EntitySetMapping in the existing EntityContainerMapping /// based on another EntitySetMapping (esmToClone) in a different artifact. /// Uses the FindMatchingEntityTypeInExistingArtifact() to match EntityTypes /// within the EntitySetMapping. /// </summary> private EntitySetMapping CloneEntitySetMapping( CommandProcessorContext cpc, EntitySetMapping esmToClone, EntityContainerMapping existingEntityContainerMapping, ConceptualEntitySet existingEntitySet, Dictionary<EntityType, EntityType> tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact) { var createESM = new CreateEntitySetMappingCommand(existingEntityContainerMapping, existingEntitySet); CommandProcessor.InvokeSingleCommand(cpc, createESM); var esm = createESM.EntitySetMapping; foreach (var etmToBeCloned in esmToClone.EntityTypeMappings()) { var bindings = etmToBeCloned.TypeName.Bindings; if (bindings.Count != 1) { Debug.Fail( "EntityTypeMapping to be cloned " + etmToBeCloned.ToPrettyString() + " has bindings count = " + bindings.Count + ". We only support 1 binding."); } else { var b = bindings.First(); var etToBeCloned = b.Target as ConceptualEntityType; Debug.Assert(etToBeCloned != null, "EntityType target of binding is not ConceptualEntityType"); var etInExistingArtifact = FindMatchingConceptualEntityTypeInExistingArtifact( etToBeCloned, tempArtifactCEntityTypeToNewCEntityTypeInExistingArtifact); if (null != etInExistingArtifact) { CreateEntityTypeMappingCommand.CloneEntityTypeMapping( cpc, etmToBeCloned, esm, etInExistingArtifact, etmToBeCloned.Kind); } else { throw new UpdateModelFromDatabaseException( string.Format( CultureInfo.CurrentCulture, Resources.UpdateFromDatabaseEntitySetMappingCannotFindEntityType, etToBeCloned.ToPrettyString())); } } } return esm; }