public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e) { base.ElementPropertyChanged(e); Association element = (Association)e.ModelElement; Store store = element.Store; Transaction current = store.TransactionManager.CurrentTransaction; ModelRoot modelRoot = store.ElementDirectory.FindElements <ModelRoot>().FirstOrDefault(); if (current.IsSerializing) { return; } List <string> errorMessages = EFCoreValidator.GetErrors(element).ToList(); switch (e.DomainProperty.Name) { case "Persistent": UpdateDisplayForPersistence(element); break; case "TargetPropertyName": errorMessages.Add(ValidateAssociationIdentifier(element, element.Source, element.Target, (string)e.NewValue)); break; case "SourcePropertyName": errorMessages.Add(ValidateAssociationIdentifier(element, element.Target, element.Source, (string)e.NewValue)); break; case "SourceMultiplicity": Multiplicity newSourceMultiplicity = (Multiplicity)e.NewValue; if ((newSourceMultiplicity == Multiplicity.One && element.TargetMultiplicity == Multiplicity.One) || (newSourceMultiplicity == Multiplicity.ZeroOne && element.TargetMultiplicity == Multiplicity.ZeroOne)) { element.SourceRole = EndpointRole.NotSet; element.TargetRole = EndpointRole.NotSet; } else { SetEndpointRoles(element); } UpdateDisplayForCascadeDelete(element, null, null, newSourceMultiplicity); break; case "TargetMultiplicity": Multiplicity newTargetMultiplicity = (Multiplicity)e.NewValue; if ((element.SourceMultiplicity == Multiplicity.One && newTargetMultiplicity == Multiplicity.One) || (element.SourceMultiplicity == Multiplicity.ZeroOne && newTargetMultiplicity == Multiplicity.ZeroOne)) { element.SourceRole = EndpointRole.NotSet; element.TargetRole = EndpointRole.NotSet; } else { SetEndpointRoles(element); } UpdateDisplayForCascadeDelete(element, null, null, null, newTargetMultiplicity); break; case "SourceRole": EndpointRole newSourceRole = (EndpointRole)e.NewValue; if (element.TargetRole == EndpointRole.NotSet && newSourceRole == EndpointRole.Dependent) { element.TargetRole = EndpointRole.Principal; } else if (element.TargetRole == EndpointRole.NotSet && newSourceRole == EndpointRole.Principal) { element.TargetRole = EndpointRole.Dependent; } break; case "TargetRole": EndpointRole newTargetRole = (EndpointRole)e.NewValue; if (element.SourceRole == EndpointRole.NotSet && newTargetRole == EndpointRole.Dependent) { element.SourceRole = EndpointRole.Principal; } else if (element.SourceRole == EndpointRole.NotSet && newTargetRole == EndpointRole.Principal) { element.SourceRole = EndpointRole.Dependent; } break; case "SourceDeleteAction": DeleteAction sourceDeleteAction = (DeleteAction)e.NewValue; UpdateDisplayForCascadeDelete(element, sourceDeleteAction); break; case "TargetDeleteAction": DeleteAction targetDeleteAction = (DeleteAction)e.NewValue; UpdateDisplayForCascadeDelete(element, null, targetDeleteAction); break; } errorMessages = errorMessages.Where(m => m != null).ToList(); if (errorMessages.Any()) { current.Rollback(); MessageBox.Show(string.Join("; ", errorMessages)); } }
/// <summary> /// Returns the property descriptors for the described Association domain class, adding tracking property /// descriptor(s). /// </summary> private PropertyDescriptorCollection GetCustomProperties(Attribute[] attributes) { // Get the default property descriptors from the base class PropertyDescriptorCollection propertyDescriptors = base.GetProperties(attributes); //Add the descriptor for the tracking property. if (ModelElement is Association association) { ModelRoot modelRoot = association.Source.ModelRoot; storeDomainDataDirectory = association.Store.DomainDataDirectory; BidirectionalAssociation bidirectionalAssociation = association as BidirectionalAssociation; // show FKPropertyName only when possible and required if (!modelRoot.ExposeForeignKeys || (association.SourceRole != EndpointRole.Dependent && association.TargetRole != EndpointRole.Dependent)) { propertyDescriptors.Remove("FKPropertyName"); } // EF6 can't have declared foreign keys for 1..1 / 0-1..1 / 1..0-1 / 0-1..0-1 relationships if (modelRoot.EntityFrameworkVersion == EFVersion.EF6 && association.SourceMultiplicity != Multiplicity.ZeroMany && association.TargetMultiplicity != Multiplicity.ZeroMany) { propertyDescriptors.Remove("FKPropertyName"); } // no FKs for aggregates if (association.Source.IsDependentType || association.Target.IsDependentType) { propertyDescriptors.Remove("FKPropertyName"); } // only display roles for 1..1 and 0-1..0-1 associations if ((association.SourceMultiplicity != Multiplicity.One || association.TargetMultiplicity != Multiplicity.One) && (association.SourceMultiplicity != Multiplicity.ZeroOne || association.TargetMultiplicity != Multiplicity.ZeroOne)) { propertyDescriptors.Remove("SourceRole"); propertyDescriptors.Remove("TargetRole"); } // only display delete behavior on the principal end // except that owned types don't have deletiion behavior choices if (association.SourceRole != EndpointRole.Principal || association.Source.IsDependentType || association.Target.IsDependentType) { propertyDescriptors.Remove("SourceDeleteAction"); } if (association.TargetRole != EndpointRole.Principal || association.Source.IsDependentType || association.Target.IsDependentType) { propertyDescriptors.Remove("TargetDeleteAction"); } // only show JoinTableName if is *..* association if (association.SourceMultiplicity != Multiplicity.ZeroMany || association.TargetMultiplicity != Multiplicity.ZeroMany) { propertyDescriptors.Remove("JoinTableName"); } // implementNotify implicitly defines autoproperty as false, so we don't display it if (association.TargetImplementNotify) { propertyDescriptors.Remove("TargetAutoProperty"); } if (bidirectionalAssociation != null && bidirectionalAssociation.SourceImplementNotify) { propertyDescriptors.Remove("SourceAutoProperty"); } // we're only allowing ..1 and ..0-1 associations to have backing fields if (association.TargetMultiplicity == Multiplicity.ZeroMany) { propertyDescriptors.Remove("TargetAutoProperty"); } if (bidirectionalAssociation != null && bidirectionalAssociation.SourceMultiplicity == Multiplicity.ZeroMany) { propertyDescriptors.Remove("SourceAutoProperty"); } // EF6 doesn't support property access modes if (modelRoot.EntityFrameworkVersion == EFVersion.EF6) { propertyDescriptors.Remove("TargetPropertyAccessMode"); propertyDescriptors.Remove("SourcePropertyAccessMode"); } // only show backing field name and property access mode if not an autoproperty if (association.TargetAutoProperty) { propertyDescriptors.Remove("TargetBackingFieldName"); propertyDescriptors.Remove("TargetPropertyAccessMode"); } if (bidirectionalAssociation == null || bidirectionalAssociation.SourceAutoProperty) { propertyDescriptors.Remove("SourceBackingFieldName"); propertyDescriptors.Remove("SourcePropertyAccessMode"); } /********************************************************************************/ //Add the descriptors for the tracking properties propertyDescriptors.Add(new TrackingPropertyDescriptor(association , storeDomainDataDirectory.GetDomainProperty(Association.CollectionClassDomainPropertyId) , storeDomainDataDirectory.GetDomainProperty(Association.IsCollectionClassTrackingDomainPropertyId) , new Attribute[] { new DisplayNameAttribute("Collection Class") , new DescriptionAttribute("Type of collections generated. Overrides the default collection class for the model") , new CategoryAttribute("Code Generation") })); if (association.TargetMultiplicity == Multiplicity.One || association.TargetMultiplicity == Multiplicity.ZeroOne) { propertyDescriptors.Add(new TrackingPropertyDescriptor(association , storeDomainDataDirectory.GetDomainProperty(Association.TargetImplementNotifyDomainPropertyId) , storeDomainDataDirectory.GetDomainProperty(Association.IsTargetImplementNotifyTrackingDomainPropertyId) , new Attribute[] { new DisplayNameAttribute("Implement INotifyPropertyChanged") , new DescriptionAttribute("Should this end participate in INotifyPropertyChanged activities? " + "Only valid for non-collection targets.") , new CategoryAttribute("End 2") })); propertyDescriptors.Add(new TrackingPropertyDescriptor(association , storeDomainDataDirectory.GetDomainProperty(Association.TargetAutoPropertyDomainPropertyId) , storeDomainDataDirectory.GetDomainProperty(Association.IsTargetAutoPropertyTrackingDomainPropertyId) , new Attribute[] { new DisplayNameAttribute("End1 Is Auto Property") , new DescriptionAttribute("If false, generates a backing field and a partial method to hook getting and setting the property. " + "If true, generates a simple auto property. Only valid for non-collection properties.") , new CategoryAttribute("End 2") })); } if (bidirectionalAssociation?.SourceMultiplicity == Multiplicity.One || bidirectionalAssociation?.SourceMultiplicity == Multiplicity.ZeroOne) { propertyDescriptors.Add(new TrackingPropertyDescriptor(bidirectionalAssociation , storeDomainDataDirectory.GetDomainProperty(BidirectionalAssociation.SourceImplementNotifyDomainPropertyId) , storeDomainDataDirectory.GetDomainProperty(BidirectionalAssociation.IsSourceImplementNotifyTrackingDomainPropertyId) , new Attribute[] { new DisplayNameAttribute("Implement INotifyPropertyChanged") , new DescriptionAttribute("Should this end participate in INotifyPropertyChanged activities? " + "Only valid for non-collection targets.") , new CategoryAttribute("End 1") })); propertyDescriptors.Add(new TrackingPropertyDescriptor(association , storeDomainDataDirectory.GetDomainProperty(BidirectionalAssociation.SourceAutoPropertyDomainPropertyId) , storeDomainDataDirectory.GetDomainProperty(BidirectionalAssociation.IsSourceAutoPropertyTrackingDomainPropertyId) , new Attribute[] { new DisplayNameAttribute("End2 Is Auto Property") , new DescriptionAttribute("If false, generates a backing field and a partial method to hook getting and setting the property. " + "If true, generates a simple auto property. Only valid for non-collection properties.") , new CategoryAttribute("End 1") })); } } // Return the property descriptors for this element return(propertyDescriptors); }
private static void DoCustomLayout(List <NodeShape> nodeShapes, List <BinaryLinkShape> linkShapes, ModelRoot modelRoot) { GeometryGraph graph = new GeometryGraph(); CreateDiagramNodes(nodeShapes, graph); CreateDiagramLinks(linkShapes, graph); AddDesignConstraints(linkShapes, modelRoot, graph); LayoutHelpers.CalculateLayout(graph, modelRoot.LayoutAlgorithmSettings, null); // Move model to positive axis. graph.UpdateBoundingBox(); graph.Translate(new Point(-graph.Left, -graph.Bottom)); UpdateNodePositions(graph); UpdateConnectors(graph); }
private void SetInitialMultiplicity(UnidirectionalAssociation element) { // valid unidirectional associations: // EF6 - entity to entity, entity to dependent // EFCore - entity to entity, entity to dependent // EFCore5Plus - entity to entity, entity to dependent, dependent to dependent, keyless to entity ModelRoot modelRoot = element.Source.ModelRoot; EFVersion entityFrameworkVersion = modelRoot.EntityFrameworkVersion; if (entityFrameworkVersion == EFVersion.EF6) { if (element.Source.IsEntity() && element.Target.IsEntity()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.ZeroMany; } if (element.Source.IsEntity() && element.Target.IsDependent()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.One; } } else if (entityFrameworkVersion == EFVersion.EFCore && !modelRoot.IsEFCore5Plus) { if (element.Source.IsEntity() && element.Target.IsEntity()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.ZeroMany; } if (element.Source.IsEntity() && element.Target.IsDependent()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.ZeroOne; } } else if (entityFrameworkVersion == EFVersion.EFCore && modelRoot.IsEFCore5Plus) { if (element.Source.IsEntity() && element.Target.IsEntity()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.ZeroMany; } if (element.Source.IsEntity() && element.Target.IsDependent()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.ZeroOne; } if (element.Source.IsDependent() && element.Target.IsDependent()) { element.SourceMultiplicity = Multiplicity.One; element.TargetMultiplicity = Multiplicity.ZeroOne; } if (element.Source.IsKeyless() && element.Target.IsEntity()) { element.SourceMultiplicity = Multiplicity.ZeroMany; element.TargetMultiplicity = Multiplicity.One; } } }
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e) { base.ElementPropertyChanged(e); ModelAttribute element = (ModelAttribute)e.ModelElement; ModelClass modelClass = element.ModelClass; ModelRoot modelRoot = modelClass.ModelRoot; Store store = element.Store; Transaction current = store.TransactionManager.CurrentTransaction; if (current.IsSerializing) { return; } if (Equals(e.NewValue, e.OldValue)) { return; } List <string> errorMessages = EFCoreValidator.GetErrors(element).ToList(); switch (e.DomainProperty.Name) { case "AutoProperty": if (element.AutoProperty && modelClass.ImplementNotify) { WarningDisplay.Show($"{modelClass.Name}.{element.Name} is an autoproperty, so will not participate in INotifyPropertyChanged messages"); } break; case "Indexed": if (element.IsIdentity) { element.Indexed = true; } if (element.IsConcurrencyToken) { element.Indexed = false; } if (element.Indexed) { element.Persistent = true; } break; case "Type": string newType = (string)e.NewValue; if (element.IsIdentity) { if (!modelRoot.ValidIdentityAttributeTypes.Contains(ModelAttribute.ToCLRType(newType))) { errorMessages.Add($"{modelClass.Name}.{element.Name}: Properties of type {newType} can't be used as identity properties."); } else { element.Required = true; element.Persistent = true; } } if (newType != "String") { element.MaxLength = 0; element.StringType = HTML5Type.None; } else { if (!element.IsValidInitialValue(newType)) { element.InitialValue = null; } } if (element.IsConcurrencyToken) { element.Type = "Binary"; } if (!element.SupportsInitialValue) { element.InitialValue = null; } break; case "MinLength": int newMinLength = (int)e.NewValue; if (element.Type != "String") { element.MinLength = 0; } if (newMinLength < 0) { errorMessages.Add($"{modelClass.Name}.{element.Name}: MinLength must be zero or a positive number"); } break; case "MaxLength": int newMaxLength = (int)e.NewValue; if (element.Type != "String") { element.MaxLength = 0; } if (newMaxLength < 0) { errorMessages.Add($"{modelClass.Name}.{element.Name}: MaxLength must be zero or a positive number"); } break; case "IdentityType": if (element.IsIdentity) { if (element.IdentityType == IdentityType.None) { errorMessages.Add($"{modelClass.Name}.{element.Name}: Identity properties must have an identity type defined"); } else { element.AutoProperty = true; } } else if (!element.IsIdentity) { element.IdentityType = IdentityType.None; } break; case "ReadOnly": if (!element.Persistent || element.SetterVisibility != SetterAccessModifier.Public) { element.ReadOnly = false; } break; case "IsIdentity": bool newIsIdentity = (bool)e.NewValue; if (newIsIdentity) { if (element.ModelClass.IsDependentType) { errorMessages.Add($"{modelClass.Name}.{element.Name}: Can't make {element.Name} an identity because {modelClass.Name} is a dependent type and can't have an identity property."); } else { if (!modelRoot.ValidIdentityAttributeTypes.Contains(element.Type)) { errorMessages.Add($"{modelClass.Name}.{element.Name}: Properties of type {element.Type} can't be used as identity properties."); } else { element.IsConcurrencyToken = false; element.Indexed = true; element.IndexedUnique = true; element.Persistent = true; element.Required = true; if (element.IdentityType == IdentityType.None) { element.IdentityType = IdentityType.AutoGenerated; } } } } else { element.IdentityType = IdentityType.None; } break; case "IsConcurrencyToken": bool newIsConcurrencyToken = (bool)e.NewValue; if (newIsConcurrencyToken) { element.IsIdentity = false; element.Persistent = true; element.Required = true; element.Type = "Binary"; } break; case "Required": bool newRequired = (bool)e.NewValue; if (!newRequired) { if (element.IsIdentity || element.IsConcurrencyToken) { element.Required = true; } } break; case "Persistent": bool newPersistent = (bool)e.NewValue; if (!newPersistent) { element.IsIdentity = false; element.Indexed = false; element.IndexedUnique = false; element.IdentityType = IdentityType.None; element.IsConcurrencyToken = false; element.Virtual = false; } break; case "Name": string newName = (string)e.NewValue; if (string.IsNullOrEmpty(newName)) { errorMessages.Add("Name must be a valid .NET identifier"); } else { ParseResult fragment; try { fragment = ModelAttribute.Parse(element.ModelClass.ModelRoot, newName); if (fragment == null) { errorMessages.Add($"{modelClass.Name}: Could not parse entry '{newName}'"); } else { if (string.IsNullOrEmpty(fragment.Name) || !CodeGenerator.IsValidLanguageIndependentIdentifier(fragment.Name)) { errorMessages.Add($"{modelClass.Name}: Property name '{fragment.Name}' isn't a valid .NET identifier"); } else if (modelClass.AllAttributes.Except(new[] { element }).Any(x => x.Name == fragment.Name)) { errorMessages.Add($"{modelClass.Name}: Property name '{fragment.Name}' already in use"); } else if (modelClass.AllNavigationProperties().Any(p => p.PropertyName == fragment.Name)) { errorMessages.Add($"{modelClass.Name}: Property name '{fragment.Name}' already in use"); } else { element.Name = fragment.Name; if (fragment.Type != null) { element.Type = fragment.Type; } if (fragment.Required != null) { element.Required = fragment.Required.Value; } if (fragment.MaxLength != null) { element.MaxLength = fragment.MaxLength.Value; } if (fragment.InitialValue != null) { element.InitialValue = fragment.InitialValue; } if (fragment.IsIdentity) { element.IsIdentity = true; // don't reset to false if not entered as part of name } } } } catch (Exception exception) { errorMessages.Add($"{modelClass.Name}: Could not parse entry '{newName}': {exception.Message}"); } } break; case "InitialValue": string newInitialValue = (string)e.NewValue; if (!element.IsValidInitialValue(null, newInitialValue)) { errorMessages.Add($"{modelClass.Name}.{element.Name}: {newInitialValue} isn't a valid value for {element.Type}"); } break; } errorMessages = errorMessages.Where(m => m != null).ToList(); if (errorMessages.Any()) { current.Rollback(); ErrorDisplay.Show(string.Join("\n", errorMessages)); } }