/// <summary> /// Deletes the passed in EntityType /// </summary> /// <param name="entityType"></param> internal DeleteEntityTypeCommand(EntityType entityType) : base(entityType) { CommandValidation.ValidateEntityType(entityType); SaveDeletedInformation(); }
protected override void InvokeInternal(CommandProcessorContext cpc) { if (_diagram != null) { // Add diagram id information in the transaction context. // This is to ensure the diagram objects are created correctly. if (cpc.EfiTransaction.GetContextValue<DiagramContextItem>(EfiTransactionOriginator.TransactionOriginatorDiagramId) == null) { cpc.EfiTransaction.AddContextValue( EfiTransactionOriginator.TransactionOriginatorDiagramId, new DiagramContextItem(_diagram.Id.Value)); } } var service = cpc.EditingContext.GetEFArtifactService(); var artifact = service.Artifact; // check if entity is in the model _createdEntity = artifact.ArtifactSet.LookupSymbol(_clipboardEntity.NormalizedName) as EntityType; if (_diagram != null && _createdEntity != null && _createdEntity is ConceptualEntityType) { if (_createdEntity.GetAntiDependenciesOfType<EntityTypeShape>().Count(ets => ets.Diagram.Id == _diagram.Id.Value) == 0) { // CreateEntityTypeShapeAndConnectorsInDiagram method will check if the shape for the entity-type has been created; // and it will not create one if the shape already exists in the diagram. // Also, VerifyDiagramModelIntegrityVisitor will assert if there are duplicate diagram shapes (shapes that point to the same model element) // every-time a command transaction is committed. So adding another check to do the same thing here is redundant. CreateEntityTypeShapeCommand.CreateEntityTypeShapeAndConnectorsInDiagram( cpc, _diagram, _createdEntity as ConceptualEntityType, _clipboardEntity.EntityTypeShapeFillColor, false); return; } } CreateEntityCopyInModel(cpc); }
public MappingFunctionEntityType(EditingContext context, EntityType entityType, MappingEFElement parent) : base(context, entityType, parent) { _insertMapping = new MappingModificationFunctionMapping(context, null, this, ModificationFunctionType.Insert); _updateMapping = new MappingModificationFunctionMapping(context, null, this, ModificationFunctionType.Update); _deleteMapping = new MappingModificationFunctionMapping(context, null, this, ModificationFunctionType.Delete); }
/// <summary> /// Creates a copy of a collection of Properties from clipboard format in the EntityType /// </summary> internal CopyPropertiesCommand( PropertiesClipboardFormat clipboardProperties, EntityType entity, InsertPropertyPosition insertPosition) { _clipboardProperties = clipboardProperties; _entity = entity; _insertPosition = insertPosition; _properties = null; }
internal CreateComplexTypeFromPropertiesCommand(EntityType entityType, List<Property> properties) { CommandValidation.ValidateConceptualEntityType(entityType); Debug.Assert(properties.Count > 0, "No properties to copy"); _entityType = entityType; _properties = properties; }
internal CreateInheritanceConnectorCommand(Diagram diagram, EntityType entity) { CommandValidation.ValidateConceptualEntityType(entity); Debug.Assert(diagram != null, "diagram is null"); _diagram = diagram; _entity = entity; }
/// <summary> /// Creates new EntityTypeMapping inside specified FunctionImportMapping /// </summary> /// <param name="functionImportMapping"></param> /// <param name="entityType"></param> internal CreateFunctionImportTypeMappingCommand(FunctionImportMapping functionImportMapping, EntityType entityType) : base(PrereqId) { CommandValidation.ValidateFunctionImportMapping(functionImportMapping); CommandValidation.ValidateEntityType(entityType); _functionImportMapping = functionImportMapping; _entityType = entityType; }
internal EntityTypeClipboardFormat(EntityType entity) : base(entity) { if (entity == null) { throw new ArgumentNullException("entity"); } _entityName = entity.LocalName.Value; var entitySet = entity.EntitySet; _navigationProperties = new List<NavigationPropertyClipboardFormat>(); var cet = entity as ConceptualEntityType; if (cet != null) { // c-side entity type // don't use base type EntitySet name if (cet.HasResolvableBaseType || entitySet == null) { _entitySetName = ModelHelper.ConstructProposedEntitySetName(entity.Artifact, _entityName); } else { _entitySetName = entitySet.LocalName.Value; } // Sort the navigation-properties based on navigation-properties' XElement orders. // This is so that we can create the copy of navigation-properties in that order. foreach (var navigationProperty in ModelHelper.GetListOfPropertiesInTheirXElementsOrder(cet.NavigationProperties().ToList()) ) { _navigationProperties.Add(new NavigationPropertyClipboardFormat(navigationProperty)); } } else { // s-side entity type // don't use base type EntitySet name if (entitySet == null) { _entitySetName = ModelHelper.ConstructProposedEntitySetName(entity.Artifact, _entityName); } else { _entitySetName = entitySet.LocalName.Value; } } _properties = new List<PropertyClipboardFormat>(); // Sort the properties based on properties's XElement order. This is that so we can create the copy of properties in that order. foreach (var property in ModelHelper.GetListOfPropertiesInTheirXElementsOrder(entity.Properties().ToList())) { _properties.Add(new PropertyClipboardFormat(property)); } }
/// <summary> /// Creates an EntitySet of the passed in EntityType in either the conceptual or the storage model. /// </summary> /// <param name="name">The name to use for this set</param> /// <param name="entityType">The EntityType that this set will contain</param> /// <param name="modelSpace">Either Conceptual or Storage</param> /// <param name="uniquifyName">Flag whether the name should be checked for uniqueness and then changed as required</param> internal CreateEntitySetCommand(string name, EntityType entityType, ModelSpace modelSpace, bool uniquifyName) { CommandValidation.ValidateEntityType(entityType); ValidateString(name); Name = name; EntityType = entityType; ModelSpaceValue = modelSpace; UniquifyName = uniquifyName; }
internal CreateEntityTypeShapeCommand(Diagram diagram, EntityType entity, Color fillColor) { CommandValidation.ValidateConceptualEntityType(entity); Debug.Assert(diagram != null, "diagram is null"); _diagram = diagram; _entity = entity; _created = null; _fillColor = fillColor; }
internal CreateFragmentScalarPropertyTreeCommand(EntityType conceptualEntityType, List<Property> properties, Property tableColumn) { CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateTableColumn(tableColumn); Debug.Assert(properties.Count > 0, "Properties list should contain at least one element"); _conceptualEntityType = conceptualEntityType; _properties = properties; _tableColumn = tableColumn; _mode = Mode.EntityType; }
/// <summary> /// Creates a Condition based on the column passed in. /// Valid combinations are: /// 1. Send true or false for isNull, and null for conditionValue /// 2. Send null for isNull, and a non-empty string for conditionValue /// 3. Send null for isNull, and null for conditionValue /// You cannot send non-null values to both arguments. /// </summary> /// <param name="conceptualEntityType"></param> /// <param name="tableColumn"></param> /// <param name="isNull"></param> /// <param name="conditionValue"></param> internal CreateFragmentConditionCommand(EntityType conceptualEntityType, Property tableColumn, bool? isNull, string conditionValue) { CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateTableColumn(tableColumn); ConceptualEntityType = conceptualEntityType; StorageProperty = tableColumn; IsNull = isNull; ConditionValue = conditionValue; Mode = ModeValues.EntityType; }
internal CreateAssociationSetMappingCommand(Association association, EntityType storageEntityType) : base(PrereqId) { CommandValidation.ValidateAssociation(association); CommandValidation.ValidateStorageEntityType(storageEntityType); EntityContainerMapping = association.Artifact.MappingModel().FirstEntityContainerMapping; AssociationSet = association.AssociationSet; Association = association; StorageEntitySet = storageEntityType.EntitySet as StorageEntitySet; }
internal CreateStorageAssociationCommand( string name, EntityType fkTable, EntityType pkTable, bool doesFkFormPk, bool isNullableFk, bool uniquifyNames) : base(PrereqId) { Name = name; FkTable = fkTable; PkTable = pkTable; DoesFkFormPk = doesFkFormPk; IsNullableFk = isNullableFk; UniquifyNames = uniquifyNames; }
/// <summary> /// Creates a ScalarProperty in a MappingFragment based on the two ends passed in. This ScalarProperty /// will always be created in the IsTypeOf ETM (key columns are also added to the Default ETM). /// </summary> /// <param name="conceptualEntityType">A C side entity</param> /// <param name="property">This must be a valid Property from the C-Model.</param> /// <param name="tableColumn">This must be a valid Property from the S-Model.</param> internal CreateFragmentScalarPropertyCommand(EntityType conceptualEntityType, Property property, Property tableColumn) { CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateConceptualProperty(property); CommandValidation.ValidateTableColumn(tableColumn); ConceptualEntityType = conceptualEntityType; Property = property; TableColumn = tableColumn; ModeValue = Mode.EntityType; }
/// <summary> /// Creates a function mapping element for the passed in Function, inside an EntityTypeMapping /// for the passed in entity. /// </summary> /// <param name="conceptualEntityType"></param> /// <param name="function"></param> /// <param name="rowsAffectedParameter">Optional string argument</param> /// <param name="type"></param> internal CreateFunctionMappingCommand( EntityType conceptualEntityType, Function function, Parameter rowsAffectedParameter, ModificationFunctionType type) { Debug.Assert(type != ModificationFunctionType.None, "You cannot pass the None type"); CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateFunction(function); _conceptualEntityType = conceptualEntityType; _function = function; _type = type; _rowsAffectedParameter = rowsAffectedParameter; }
/// <summary> /// Create MappingFragment for the passed in ConceptualEntityType and StoreEntityType, and inside the /// ETM based on the passed in kind. /// </summary> /// <param name="conceptualEntityType">This must be a valid EntityType from the C-Model.</param> /// <param name="storeEntityType">This must be a valid EntityType from the S-Model.</param> /// <param name="kind">Specify whether this should be put in an IsTypeOf or Default ETM</param> internal CreateMappingFragmentCommand(EntityType conceptualEntityType, EntityType storeEntityType, EntityTypeMappingKind kind) { CommandValidation.ValidateStorageEntityType(storeEntityType); CommandValidation.ValidateConceptualEntityType(conceptualEntityType); ConceptualEntityType = conceptualEntityType; _entityTypeMappingKind = kind; _entityTypeMapping = null; StorageEntitySet = storeEntityType.EntitySet as StorageEntitySet; CommandValidation.ValidateStorageEntitySet(StorageEntitySet); }
/// <summary> /// Creates a ComplexProperty in a MappingFragment based on conceptualEntityType passed in. /// </summary> /// <param name="conceptualEntityType">A C side entity</param> /// <param name="property">This must be a valid Property from the C-Model.</param> /// <param name="tableColumn">This must be a valid Property from the S-Model.</param> internal CreateFragmentComplexPropertyCommand( EntityType conceptualEntityType, ComplexConceptualProperty property, Property tableColumn) : base(PrereqId) { CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateConceptualProperty(property); CommandValidation.ValidateTableColumn(tableColumn); _conceptualEntityType = conceptualEntityType; _property = property; _tableColumn = tableColumn; _mode = Mode.EntityType; }
/// <summary> /// Creates a ResultBinding element that maps the passed in Property to the result column, inside /// an EntityTypeMapping for the passed in entity. The Function is used to locate the correct /// ModificationFunction to house this. /// </summary> /// <param name="conceptualEntityType"></param> /// <param name="function"></param> /// <param name="entityProperty">Optional</param> /// <param name="columnName">Optional</param> internal CreateResultBindingCommand( EntityType conceptualEntityType, Function function, ModificationFunctionType functionType, Property entityProperty, string columnName) { CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateFunction(function); Debug.Assert(functionType != ModificationFunctionType.None, "You cannot pass the None type"); _conceptualEntityType = conceptualEntityType; _function = function; _functionType = functionType; _entityProperty = entityProperty; _columnName = columnName; }
/// <summary> /// Creates a property in the passed in entity. /// </summary> /// <param name="name">The name of the new property</param> /// <param name="entityType">The entity to create the property in</param> /// <param name="type">The type of the property</param> /// <param name="nullable">Flag whether the property is nullable or not</param> internal CreatePropertyCommand( string name, EntityType entityType, string type, bool? nullable, InsertPropertyPosition insertPosition) : base(PrereqId) { ValidateString(name); CommandValidation.ValidateEntityType(entityType); ValidateString(type); Name = name; EntityType = entityType; Type = type; Nullable = nullable; _insertPosition = insertPosition; }
/// <summary> /// Creates a ComplexProperty in the given MappingFragment. /// </summary> /// <param name="mappingFragment">The MappingFragment to place this ComplexProperty; cannot be null.</param> /// <param name="property">This must be a valid ComplexTypeProperty.</param> /// <param name="isPartial"></param> internal CreateFragmentComplexPropertyCommand(MappingFragment mappingFragment, ComplexConceptualProperty property) : base(PrereqId) { CommandValidation.ValidateMappingFragment(mappingFragment); CommandValidation.ValidateConceptualProperty(property); _mappingFragment = mappingFragment; if (mappingFragment != null && mappingFragment.EntityTypeMapping != null) { _conceptualEntityType = mappingFragment.EntityTypeMapping.FirstBoundConceptualEntityType; } _property = property; _mode = Mode.MappingFragment; }
/// <summary> /// Creates a copy of Property from a Clipboard format in the specified EntityType and Position. /// </summary> /// <param name="entityType">The entity to create the property in</param> /// <param name="clipboardProperty"></param> /// <param name="insertPosition">Information where the property should be inserted to. If the parameter is null, the property will be placed as the last property of the entity.</param> /// <returns></returns> internal CopyPropertyCommand(PropertyClipboardFormat clipboardProperty, EntityType entity, InsertPropertyPosition insertPosition) { if (_insertPosition != null) { Debug.Assert( entity.EntityModel.IsCSDL, "You can only set insertPosition parameter if the EntityType is a ConceptualEntityType."); Debug.Assert( insertPosition.InsertAtProperty != null && insertPosition.InsertAtProperty.EntityType == entity, "Could not create complex property in the given insertPosition because insertPosition's Entity-Type is not the same as the entity-type which the property will be created in."); } CommandValidation.ValidateEntityType(entity); _clipboardProperty = clipboardProperty; _entityType = entity; _insertPosition = insertPosition; }
internal CreateFragmentScalarPropertyTreeCommand(MappingFragment mappingFragment, List<Property> properties, Property tableColumn) { CommandValidation.ValidateMappingFragment(mappingFragment); CommandValidation.ValidateTableColumn(tableColumn); Debug.Assert(properties.Count > 0, "Properties list should contain at least one element"); _mappingFragment = mappingFragment; if (mappingFragment != null && mappingFragment.EntityTypeMapping != null) { _conceptualEntityType = mappingFragment.EntityTypeMapping.FirstBoundConceptualEntityType; } _properties = properties; _tableColumn = tableColumn; _mode = Mode.MappingFragment; }
/// <summary> /// Creates a ComplexProperty in the specified position in the entity. /// </summary> /// <param name="name">The name of the new property</param> /// <param name="entityType">The entity to create the property in</param> /// <param name="typeName">String representing the type of the property (needs to be a ref name to a ComplexType)</param> /// <param name="insertPosition">Information where the property should be inserted to. If the parameter is null, the property will be placed as the last property of the entity.</param> internal CreateComplexPropertyCommand(string name, EntityType entityType, string typeName, InsertPropertyPosition insertPosition) { if (insertPosition != null) { Debug.Assert( insertPosition.InsertAtProperty != null && insertPosition.InsertAtProperty.EntityType == entityType, "Could not create complex property in the given insertPosition because insertPosition's Entity-Type is not the same as the entity-type which the property will be created in."); } ValidateString(name); CommandValidation.ValidateEntityType(entityType); Name = name; EntityType = entityType; _typeName = typeName; _insertPosition = insertPosition; }
/// <summary> /// Delete a function mapping. The function mapping is located using the passed in EntityType to validate /// the EntityTypeMapping and then the Function to locate the mapping itself. /// </summary> /// <param name="conceptualEntityType"></param> /// <param name="function"></param> /// <param name="type"></param> internal DeleteFunctionMappingCommand(EntityType conceptualEntityType, Function function, ModificationFunctionType type) : base((EFElement)null) { CommandValidation.ValidateConceptualEntityType(conceptualEntityType); CommandValidation.ValidateFunction(function); foreach (var mf in function.GetAntiDependenciesOfType<ModificationFunction>()) { if (mf.ModificationFunctionMapping.EntityTypeMapping.FirstBoundConceptualEntityType == conceptualEntityType && mf.FunctionType == type) { EFElement = mf; break; } } // don't throw now in the c'tor Debug.Assert(ModificationFunction != null, "Couldn't find the ModificationFunction needed to complete this operation"); }
private void AddDbObjToEntityTypeNameMap(DatabaseObject key, EntityType et) { var normalizedName = et.NormalizedName; if (normalizedName == null) { Debug.Fail("null or empty Normalized Name for " + et.ToPrettyString()); return; } HashSet<Symbol> entityTypeNamesHashSet = null; _databaseObjectToCEntityTypeNamesMap.TryGetValue(key, out entityTypeNamesHashSet); if (null == entityTypeNamesHashSet) { entityTypeNamesHashSet = _databaseObjectToCEntityTypeNamesMap[key] = new HashSet<Symbol>(); } entityTypeNamesHashSet.Add(normalizedName); }
private void AddCEntityTypeNameToEntityTypeIdentityMapping( EntityType key, DatabaseObject dbObj) { var normalizedName = key.NormalizedName; if (normalizedName == null) { Debug.Fail("null or empty Normalized Name for " + key.ToPrettyString()); return; } EntityTypeIdentity etId = null; _cEntityTypeNameToEntityTypeIdentity.TryGetValue(normalizedName, out etId); if (null == etId) { etId = _cEntityTypeNameToEntityTypeIdentity[normalizedName] = new EntityTypeIdentity(); } etId.AddTableOrView(dbObj); }
internal EntityTypeIdentity GetEntityTypeIdentityForEntityType(EntityType et) { var normalizedName = et.NormalizedName; if (normalizedName == null) { Debug.Fail("null or empty Normalized Name for " + et.ToPrettyString()); return null; } EntityTypeIdentity results; _cEntityTypeNameToEntityTypeIdentity.TryGetValue(normalizedName, out results); return results; }
/// <summary> /// Gets the AssociationEnd that is not pointing to the given EntityType. This method should not be /// called for self-associations. /// </summary> /// <param name="oneEnd"></param> /// <returns></returns> internal AssociationEnd GetOtherEnd(EntityType entityType) { Debug.Assert( !IsSelfAssociation, "GetOtherEnd() will not work correctly for self associations as both ends point to the same entity type"); AssociationEnd otherEnd = null; if (End1.Type.Target == entityType) { otherEnd = End2; } else if (End2.Type.Target == entityType) { otherEnd = End1; } return otherEnd; }
/// <summary> /// Get all associations which the entity type participates in. /// </summary> /// <param name="entityType"></param> /// <returns></returns> internal static HashSet<Association> GetAssociationsForEntityType(EntityType entityType) { // Add association connectors var participatingAssociations = new HashSet<Association>(); // First we find all the associations which the entitytype participates. foreach (var associationEnd in entityType.GetAntiDependenciesOfType<AssociationEnd>()) { var association = associationEnd.Parent as Association; if (association != null && participatingAssociations.Contains(association) == false) { participatingAssociations.Add(association); } } return participatingAssociations; }