Beispiel #1
0
        protected override void PreParse()
        {
            Debug.Assert(State != EFElementState.Parsed, "this object should not already be in the parsed state");

            ClearEFObjectCollection(_ends);
            ClearEFObject(_referentialConstraint);
            _referentialConstraint = null;

            base.PreParse();
        }
 internal static AssociationIdentity CreateAssociationIdentity(ReferentialConstraint rc)
 {
     if (rc == null)
     {
         Debug.Fail("You passed a null Referential Constraint to CreateAssociationIdentity!");
     }
     else
     {
         var id = new AssociationIdentityForReferentialConstraint(rc);
         return id;
     }
     return null;
 }
Beispiel #3
0
        protected override void OnChildDeleted(EFContainer efContainer)
        {
            var child = efContainer as AssociationEnd;

            if (child != null)
            {
                _ends.Remove(child);
                return;
            }

            if (efContainer == _referentialConstraint)
            {
                _referentialConstraint = null;
                return;
            }

            base.OnChildDeleted(efContainer);
        }
 public ReferentialConstraintClipboardFormat(ReferentialConstraint referentialConstraint)
     : base(referentialConstraint)
 {
     _principalRole       = referentialConstraint.Principal.Role.RefName;
     _principalProperties = new List <string>(referentialConstraint.Principal.PropertyRefs.Count);
     foreach (var propertyRef in referentialConstraint.Principal.PropertyRefs)
     {
         _principalProperties.Add(propertyRef.Name.RefName);
         if (_principalEntityName == null &&
             propertyRef.Name.Target.EntityType != null)
         {
             _principalEntityName = propertyRef.Name.Target.EntityType.LocalName.Value;
         }
     }
     _dependentRole       = referentialConstraint.Dependent.Role.RefName;
     _dependentProperties = new List <string>(referentialConstraint.Dependent.PropertyRefs.Count);
     foreach (var propertyRef in referentialConstraint.Dependent.PropertyRefs)
     {
         _dependentProperties.Add(propertyRef.Name.RefName);
     }
 }
 public ReferentialConstraintClipboardFormat(ReferentialConstraint referentialConstraint)
     : base(referentialConstraint)
 {
     _principalRole = referentialConstraint.Principal.Role.RefName;
     _principalProperties = new List<string>(referentialConstraint.Principal.PropertyRefs.Count);
     foreach (var propertyRef in referentialConstraint.Principal.PropertyRefs)
     {
         _principalProperties.Add(propertyRef.Name.RefName);
         if (_principalEntityName == null
             && propertyRef.Name.Target.EntityType != null)
         {
             _principalEntityName = propertyRef.Name.Target.EntityType.LocalName.Value;
         }
     }
     _dependentRole = referentialConstraint.Dependent.Role.RefName;
     _dependentProperties = new List<string>(referentialConstraint.Dependent.PropertyRefs.Count);
     foreach (var propertyRef in referentialConstraint.Dependent.PropertyRefs)
     {
         _dependentProperties.Add(propertyRef.Name.RefName);
     }
 }
 internal override bool ParseSingleElement(ICollection<XName> unprocessedElements, XElement elem)
 {
     if (elem.Name.LocalName == AssociationEnd.ElementName)
     {
         var assocEnd = new AssociationEnd(this, elem);
         _ends.Add(assocEnd);
         assocEnd.Parse(unprocessedElements);
     }
     else if (elem.Name.LocalName == ReferentialConstraint.ElementName)
     {
         if (_referentialConstraint != null)
         {
             var msg = String.Format(
                 CultureInfo.CurrentCulture, Resources.TOO_MANY_REFERENTIAL_CONSTRAINTS_IN_ASSOCIATION, LocalName.Value);
             Artifact.AddParseErrorForObject(this, msg, ErrorCodes.TOO_MANY_REFERENTIAL_CONSTRAINTS_IN_ASSOCIATION);
         }
         else
         {
             _referentialConstraint = new ReferentialConstraint(this, elem);
             _referentialConstraint.Parse(unprocessedElements);
         }
     }
     else
     {
         return base.ParseSingleElement(unprocessedElements, elem);
     }
     return true;
 }
        protected override void PreParse()
        {
            Debug.Assert(State != EFElementState.Parsed, "this object should not already be in the parsed state");

            ClearEFObjectCollection(_ends);
            ClearEFObject(_referentialConstraint);
            _referentialConstraint = null;

            base.PreParse();
        }
        protected override void OnChildDeleted(EFContainer efContainer)
        {
            var child = efContainer as AssociationEnd;
            if (child != null)
            {
                _ends.Remove(child);
                return;
            }

            if (efContainer == _referentialConstraint)
            {
                _referentialConstraint = null;
                return;
            }

            base.OnChildDeleted(efContainer);
        }
 private AssociationIdentityForReferentialConstraint(ReferentialConstraint rc)
 {
     _referentialConstraintIdentity = ReferentialConstraintIdentity.CreateReferentialConstraintIdentity(rc);
 }
        protected override void InvokeInternal(CommandProcessorContext cpc)
        {
            Debug.Assert(
                PrincipalEnd != null && DependentEnd != null, "InvokeInternal is called when PrincipalEnd or DependentEnd is null.");
            if (PrincipalEnd == null
                || DependentEnd == null)
            {
                throw new InvalidOperationException("InvokeInternal is called when PrincipalEnd or DependentEnd is null.");
            }

            var association = PrincipalEnd.Parent as Association;
            Debug.Assert(
                association != null && association == DependentEnd.Parent, "Association parent for both ends must agree and be not null");

            var principalProps = PrincipalProperties.ToList();
            var dependentProps = DependentProperties.ToList();

            Debug.Assert(principalProps.Count == dependentProps.Count, "Number of principal and dependent properties must agree");
            Debug.Assert(principalProps.Count > 0, "Number of properties must be positive");

            var referentialConstraint = new ReferentialConstraint(association, null);
            association.ReferentialConstraint = referentialConstraint;
            XmlModelHelper.NormalizeAndResolve(referentialConstraint);

            var principalRole = new ReferentialConstraintRole(referentialConstraint, null);
            var dependentRole = new ReferentialConstraintRole(referentialConstraint, null);

            var service = cpc.EditingContext.GetEFArtifactService();
            // we can't pass the type of referential constraint role ("Principal" or "Dependent")
            // in the constructor because XElement gets created in base constructor
            // before we have a chance to set any properties
            if (association.EntityModel.IsCSDL)
            {
                var csdlNamespaceName = SchemaManager.GetCSDLNamespaceName(service.Artifact.SchemaVersion);
                principalRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNamePrincipal, csdlNamespaceName);
                dependentRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNameDependent, csdlNamespaceName);
            }
            else
            {
                var ssdlNamespaceName = SchemaManager.GetSSDLNamespaceName(service.Artifact.SchemaVersion);
                principalRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNamePrincipal, ssdlNamespaceName);
                dependentRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNameDependent, ssdlNamespaceName);
            }

            principalRole.Role.SetRefName(PrincipalEnd);
            dependentRole.Role.SetRefName(DependentEnd);

            referentialConstraint.Principal = principalRole;
            referentialConstraint.Dependent = dependentRole;

            XmlModelHelper.NormalizeAndResolve(principalRole);
            XmlModelHelper.NormalizeAndResolve(dependentRole);

            for (var i = 0; i < principalProps.Count; i++)
            {
                principalRole.AddPropertyRef(principalProps[i]);
                dependentRole.AddPropertyRef(dependentProps[i]);
            }

            Debug.Assert(
                principalProps.Count == 0
                || (principalRole.PropertyRefs.First().Name.Target != null && dependentRole.PropertyRefs.First().Name.Target != null),
                "Unresolved property references");

            _createdRefConstraint = referentialConstraint;
        }
 internal void SetCreatedReferentialConstraint(ReferentialConstraint refConstraint)
 {
     _createdRefConstraint = refConstraint;
 }
 internal DeleteReferentialConstraintCommand(ReferentialConstraint referentialConstraint)
     : base(referentialConstraint)
 {
 }
        /// <summary>
        ///     Determines whether we should create an Association in the existing artifact given
        ///     the ReferentialConstraint and AssociationEnd info from the temp artifact
        /// </summary>
        private static bool ShouldCreateAssociationGivenReferentialConstraint(
            ReferentialConstraint refConstraintInTempArtifact,
            AssociationEnd end1InTempArtifact, AssociationEnd end2InTempArtifact,
            ConceptualEntityType end1EntityTypeInExistingArtifact, ConceptualEntityType end2EntityTypeInExistingArtifact,
            out bool end1IsPrincipalEnd, out List<Property> principalPropertiesInExistingArtifact,
            out List<Property> dependentPropertiesInExistingArtifact, out List<string> unfoundPrincipalProperties,
            out List<string> unfoundDependentProperties)
        {
            end1IsPrincipalEnd = true;
            principalPropertiesInExistingArtifact = new List<Property>();
            unfoundPrincipalProperties = new List<string>();
            dependentPropertiesInExistingArtifact = new List<Property>();
            unfoundDependentProperties = new List<string>();
            ConceptualEntityType principalEndEntityType = null;
            ConceptualEntityType dependentEndEntityType = null;

            if (refConstraintInTempArtifact == null)
            {
                Debug.Fail("Should not have null ReferentialConstraint");
                // no ReferentialConstraint in temp artifact to clone
                return false;
            }

            // determine which end is principal and which dependent
            if (refConstraintInTempArtifact.Principal.Role.Target == end1InTempArtifact)
            {
                Debug.Assert(
                    refConstraintInTempArtifact.Dependent.Role.Target == end2InTempArtifact,
                    "Unexpected end value for Dependent Role of ReferentialConstraint when Principal Role matches end1 from temp artifact");
                end1IsPrincipalEnd = true;
                principalEndEntityType = end1EntityTypeInExistingArtifact;
                dependentEndEntityType = end2EntityTypeInExistingArtifact;
            }
            else if (refConstraintInTempArtifact.Principal.Role.Target == end2InTempArtifact)
            {
                Debug.Assert(
                    refConstraintInTempArtifact.Dependent.Role.Target == end1InTempArtifact,
                    "Unexpected end value for Dependent Role of ReferentialConstraint when Principal Role matches end2 from temp artifact");
                end1IsPrincipalEnd = false;
                principalEndEntityType = end2EntityTypeInExistingArtifact;
                dependentEndEntityType = end1EntityTypeInExistingArtifact;
            }
            else
            {
                Debug.Fail("Couldn't identify principal & dependent end");
                return false;
            }

            // find the principal properties in the existing doc to include in the referential constraint
            foreach (var tempProp in refConstraintInTempArtifact.Principal.Properties)
            {
                var prop = FindMatchingPropertyInExistingArtifactEntityType(tempProp, principalEndEntityType);
                if (prop != null)
                {
                    principalPropertiesInExistingArtifact.Add(prop);
                }
                else
                {
                    unfoundPrincipalProperties.Add(tempProp.LocalName.Value);
                }
            }

            // find the dependent properties in the existing doc to include in the referential constraint
            foreach (var tempProp in refConstraintInTempArtifact.Dependent.Properties)
            {
                var prop = FindMatchingPropertyInExistingArtifactEntityType(tempProp, dependentEndEntityType);
                if (prop != null)
                {
                    dependentPropertiesInExistingArtifact.Add(prop);
                }
                else
                {
                    unfoundDependentProperties.Add(tempProp.LocalName.Value);
                }
            }

            // return true if we found matching properties for all the properties in
            // both the principal and dependent ends, false otherwise
            if (unfoundDependentProperties.Count == 0
                && unfoundPrincipalProperties.Count == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }