protected override void InvokeInternal(CommandProcessorContext cpc) { // if the DesignerInfoPropertySet doesn't exist then we need to create it. if (_designerInfo.PropertySet == null) { _designerInfo.PropertySet = new DesignerInfoPropertySet(_designerInfo, null); } // if the DesignerProperty doesn't exist then we need to create it. DesignerProperty designerProperty; if (!_designerInfo.PropertySet.TryGetDesignerProperty(_name, out designerProperty)) { designerProperty = new DesignerProperty(_designerInfo.PropertySet, null); designerProperty.LocalName.Value = _name; _designerInfo.PropertySet.AddDesignerProperty(_name, designerProperty); } // First let's check make sure any non-valid values are caught up the stack if (!designerProperty.ValueAttr.IsValidValue(_value)) { throw new CommandValidationFailedException( String.Format(CultureInfo.CurrentCulture, Resources.NonValidDesignerProperty, _value, _name)); } // now we update the value of the designer property var cmdUpdateDefaultableValue = new UpdateDefaultableValueCommand <string>(designerProperty.ValueAttr, _value); CommandProcessor.InvokeSingleCommand(cpc, cmdUpdateDefaultableValue); // normalize and resolve the entire DesignerInfo XmlModelHelper.NormalizeAndResolve(_designerInfo); }
protected override void InvokeInternal(CommandProcessorContext cpc) { if (!string.IsNullOrEmpty(Role) && !string.Equals(End.Role.Value, Role, StringComparison.Ordinal)) { // TODO: should this command be enqueued in the command processor? RenameCommand c = new EntityDesignRenameCommand(End, Role, true); CommandProcessor.InvokeSingleCommand(cpc, c); // bug 563525: we need to update EndProperties within AssociationSetMappings if the AssociationEnd changes. // we update the "Role" of an AssociationSetEnd in the RenameCommand but the SingleItemBinding that we have to update // that is bound to the AssociationSetEnd is unique to this situation; it is not technically a "refactor rename". var associationSetEnd = End.GetAntiDependenciesOfType <AssociationSetEnd>().FirstOrDefault(); if (associationSetEnd != null) { // we need to renormalize the associationSetEnd, since the role name will have changed. XmlModelHelper.NormalizeAndResolve(associationSetEnd); var endPropertiesInAssocSetMappings = associationSetEnd.GetAntiDependenciesOfType <EndProperty>(); foreach (var endProperty in endPropertiesInAssocSetMappings) { endProperty.Name.SetRefName(associationSetEnd); CheckArtifactBindings.ScheduleBindingsForRebind(cpc, new HashSet <ItemBinding> { endProperty.Name }); } } } }
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); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var service = cpc.EditingContext.GetEFArtifactService(); var artifact = service.Artifact; var function = new Function(artifact.StorageModel(), null); function.Name.Value = Name; function.Schema.Value = SchemaName; function.IsComposable.Value = IsComposable; function.ReturnType.Value = ReturnType; if (Name != StoreFunctionName) { function.StoreFunctionName.Value = StoreFunctionName; } foreach (var parameterInfo in ParameterInfos) { var parameter = new Parameter(function, null); parameter.Name.Value = parameterInfo.Name; parameter.Mode.Value = parameterInfo.Mode; parameter.Type.Value = parameterInfo.Type; function.AddParameter(parameter); } artifact.StorageModel().AddFunction(function); XmlModelHelper.NormalizeAndResolve(function); CreatedFunction = function; }
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; }
protected override void InvokeInternal(CommandProcessorContext cpc) { // safety check, this should never be hit Debug.Assert(_binding != null, "InvokeInternal is called when _binding is null."); if (_binding == null) { throw new InvalidOperationException("InvokeInternal is called when _binding is null"); } // set new values in if we were sent them if (_entityProperty != null && _binding.Name.Target != _entityProperty) { _binding.Name.SetRefName(_entityProperty); } // set new values in if we were sent them if (_columnName != null && !string.Equals(_binding.ColumnName.Value, _columnName, StringComparison.CurrentCulture)) { _binding.ColumnName.Value = _columnName; } XmlModelHelper.NormalizeAndResolve(_binding); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var cp = new CommandProcessor(cpc); CreateFunctionComplexPropertyCommand preReqCmd = null; for (var i = 0; i < _propertyChain.Count; i++) { var property = _propertyChain[i]; Debug.Assert(property.EntityModel.IsCSDL, "Each Property in the chain must be in the CSDL"); var complexConceptualProperty = property as ComplexConceptualProperty; if (complexConceptualProperty != null) { Debug.Assert(i < _propertyChain.Count - 1, "Last property shouldn't be ComplexConceptualProperty"); CreateFunctionComplexPropertyCommand cmd = null; if (preReqCmd == null) { // first property has a mapping whose parent is the ModificationFunction itself cmd = new CreateFunctionComplexPropertyCommand(_modificationFunction, complexConceptualProperty); } else { // later properties have a mapping whose parent is the ComplexProperty produced from the previous command cmd = new CreateFunctionComplexPropertyCommand(preReqCmd, complexConceptualProperty); } // set up the prereq Command to use for next time around this loop and for the // CreateFunctionScalarPropertyCommand below preReqCmd = cmd; // enqueue the command cp.EnqueueCommand(cmd); } else { Debug.Assert(i == _propertyChain.Count - 1, "This should be the last property"); CreateFunctionScalarPropertyCommand cmd = null; if (preReqCmd == null) { // create the FunctionScalarProperty command without any other properties in the property chain cmd = new CreateFunctionScalarPropertyCommand( _modificationFunction, property, _navPropPointingToProperty, _parameter, _version); } else { // create the FunctionScalarProperty command using the command for the previous property in the property chain cmd = new CreateFunctionScalarPropertyCommand(preReqCmd, property, _navPropPointingToProperty, _parameter, _version); } cp.EnqueueCommand(cmd); cp.Invoke(); _createdProperty = cmd.FunctionScalarProperty; if (_createdProperty != null) { XmlModelHelper.NormalizeAndResolve(_createdProperty); } return; } } }
protected override void InvokeInternal(CommandProcessorContext cpc) { Debug.Assert(cpc != null, "InvokeInternal is called when EntityContainerMapping is null."); // safety check, this should never be hit if (EntityType == null) { throw new InvalidOperationException("InvokeInternal is called when entity type is null"); } EntityType.Abstract.Value = SetAbstract; // remove any function mappings if we are setting this to abstract if (SetAbstract) { var etms = new List <EntityTypeMapping>(); etms.AddRange(EntityType.GetAntiDependenciesOfType <EntityTypeMapping>()); for (var i = etms.Count - 1; i >= 0; i--) { var etm = etms[i]; if (etm != null && etm.Kind == EntityTypeMappingKind.Function) { DeleteEFElementCommand.DeleteInTransaction(cpc, etm); } } } XmlModelHelper.NormalizeAndResolve(EntityType); }
protected override void InvokeInternal(CommandProcessorContext cpc) { // check that we have an existing artifact var service = cpc.EditingContext.GetEFArtifactService(); var existingArtifact = service.Artifact as EntityDesignArtifact; if (null == existingArtifact) { Debug.Fail("Null Artifact in ReplaceSsdlCommand.InvokeInternal()"); return; } // replace the old SSDL with the new ReplaceSsdl(cpc, existingArtifact, _newSsdlReader); // replace the old MSL with the new ReplaceMsl(cpc, existingArtifact, _newMslReader); // normalize and resolve the StorageModel XmlModelHelper.NormalizeAndResolve(existingArtifact.StorageModel); Debug.Assert(EFElementState.Resolved == existingArtifact.StorageModel.State, "StorageModel State should be Resolved"); // normalize and resolve the MappingModel XmlModelHelper.NormalizeAndResolve(existingArtifact.MappingModel); Debug.Assert(EFElementState.Resolved == existingArtifact.MappingModel.State, "MappingModel State should be Resolved"); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var associationSetMapping = ModelHelper.FindAssociationSetMappingForConceptualAssociation(Association); if (associationSetMapping == null) { // This AssociationSetMapping does not exist, create it base.InvokeInternal(cpc); associationSetMapping = AssociationSetMapping; Debug.Assert(associationSetMapping != null, "Could not create AssociationSetMapping"); } else { // The AssociationSetMapping already exists, update it associationSetMapping.Name.SetRefName(AssociationSet); associationSetMapping.TypeName.SetRefName(Association); associationSetMapping.StoreEntitySet.SetRefName(StorageEntitySet); XmlModelHelper.NormalizeAndResolve(associationSetMapping); Debug.Assert(associationSetMapping.Name.Target != null, "Could not resolve association set reference"); Debug.Assert(associationSetMapping.TypeName.Target != null, "Could not resolve association type reference"); Debug.Assert(associationSetMapping.StoreEntitySet.Target != null, "Could not resolve table reference"); InferReferentialConstraints.AddRule(cpc, Association); } }
private static FunctionComplexProperty CreateNewFunctionComplexProperty(EFElement parent, ComplexConceptualProperty property) { Debug.Assert(property != null, "CreateFunctionComplexPropertyCommand.CreateNewFunctionComplexProperty() received null property"); Debug.Assert (property.ComplexType.Target != null, typeof(CreateFunctionComplexPropertyCommand).Name + ".CreateNewFunctionComplexProperty() received property with null ComplexType.Target"); // actually create it in the XLinq tree var fcp = new FunctionComplexProperty(parent, null); fcp.Name.SetRefName(property); fcp.TypeName.SetRefName(property.ComplexType.Target); XmlModelHelper.NormalizeAndResolve(fcp); if (fcp == null) { throw new ItemCreationFailureException(); } Debug.Assert( fcp.Name.Target != null && fcp.Name.Target.LocalName.Value == fcp.Name.RefName, (fcp.Name.Target == null ? "Broken property resolution for FunctionComplexProperty " + fcp.ToPrettyString() + ": null Target" : "Broken property resolution for FunctionComplexProperty " + fcp.ToPrettyString() + ": Target.LocalName = " + fcp.Name.Target.LocalName.Value + ", RefName = " + fcp.Name.RefName)); return(fcp); }
internal void layer_EntityDesignerSelectionChanged(object sender, ChangeEntityDesignerSelectionEventArgs e) { if (PackageManager.Package.DocumentFrameMgr != null && PackageManager.Package.DocumentFrameMgr.EditingContextManager != null) { if (PackageManager.Package.DocumentFrameMgr.EditingContextManager.DoesContextExist(_artifact.Uri)) { var editingContext = PackageManager.Package.DocumentFrameMgr.EditingContextManager.GetNewOrExistingContext( _artifact.Uri); Debug.Assert(editingContext != null, "EditingContext must not be null if we found that a context exists"); if (editingContext != null) { // TODO handle multiple selection at some point var selectedItems = new List <EFNameableItem>(); foreach (var selectionIdentifier in e.SelectionIdentifiers) { if (!String.IsNullOrEmpty(selectionIdentifier)) { var nameableItem = XmlModelHelper.FindNameableItemViaIdentifier( _artifact.ConceptualModel(), selectionIdentifier); if (nameableItem != null) { selectedItems.Add(nameableItem); } } } if (selectedItems.Count > 0) { editingContext.Items.SetValue(new LayerSelection(selectedItems)); } } } } }
protected override void InvokeInternal(CommandProcessorContext cpc) { if (_entityProperty != null) { Debug.Assert(_entityProperty.EntityModel.IsCSDL, "_entityProperty should be from C-side model"); ScalarProperty.Name.SetRefName(_entityProperty); } if (TableColumn != null) { Debug.Assert(TableColumn.EntityModel.IsCSDL != true, "_tableColumn should not be from C-side model"); ScalarProperty.ColumnName.SetRefName(TableColumn); } XmlModelHelper.NormalizeAndResolve(ScalarProperty); // if we change a scalar in an association mapping, make sure that we still have good MSL if (ScalarProperty.EndProperty != null) { var asm = ScalarProperty.EndProperty.Parent as AssociationSetMapping; Debug.Assert(asm != null, "_sp.EndProperty parent is not an AssociationSetMapping"); if (asm != null) { EnforceAssociationSetMappingRules.AddRule(cpc, asm); var assoc = asm.TypeName.Target; Debug.Assert(assoc != null, "Could not resolve association reference"); if (assoc != null) { InferReferentialConstraints.AddRule(cpc, assoc); } } } }
protected override void InvokeInternal(CommandProcessorContext cpc) { try { // check that we have an existing artifact var service = cpc.EditingContext.GetEFArtifactService(); var existingArtifact = service.Artifact as EntityDesignArtifact; Debug.Assert(existingArtifact != null, "Null Artifact in ReplaceCsdlAndMslCommand.InvokeInternal()"); if (null == existingArtifact) { return; } // replace the old CSDL with the new ReplaceCsdl(cpc, existingArtifact, _newCsdlReader); // replace the old MSL with the new ReplaceMsl(cpc, existingArtifact, _newMslReader); // normalize and resolve the ConceptualModel XmlModelHelper.NormalizeAndResolve(existingArtifact.ConceptualModel); Debug.Assert(EFElementState.Resolved == existingArtifact.ConceptualModel.State, "ConceptualModel State should be Resolved"); // normalize and resolve the MappingModel XmlModelHelper.NormalizeAndResolve(existingArtifact.MappingModel); Debug.Assert(EFElementState.Resolved == existingArtifact.MappingModel.State, "MappingModel State should be Resolved"); } finally { Cleanup(); } }
protected override void InvokeInternal(CommandProcessorContext cpc) { if (String.IsNullOrEmpty(_longDescriptionText)) { if (_efElement.Documentation != null && _efElement.Documentation.LongDescription != null) { DeleteEFElementCommand.DeleteInTransaction(cpc, _efElement.Documentation.LongDescription); // if the documentation node is empty, delete it if (_efElement.Documentation.Summary == null) { DeleteEFElementCommand.DeleteInTransaction(cpc, _efElement.Documentation); } } } else { if (_efElement.Documentation == null) { _efElement.Documentation = new Documentation(_efElement, null); } if (_efElement.Documentation.LongDescription == null) { _efElement.Documentation.LongDescription = new LongDescription(_efElement.Documentation, null); } _efElement.Documentation.LongDescription.Text = _longDescriptionText; XmlModelHelper.NormalizeAndResolve(_efElement); } }
protected override void InvokeInternal(CommandProcessorContext cpc) { var nExistingTypeShapeCount = _entity.GetAntiDependenciesOfType <EntityTypeShape>().Count(ets => ets.Diagram.Id == _diagram.Id.Value); Debug.Assert( nExistingTypeShapeCount == 0, "There is already Entity Type Shape for entity :" + _entity.Name + " in the diagram " + _diagram.Name); if (nExistingTypeShapeCount == 0) { var shape = new EntityTypeShape(_diagram, null); _diagram.AddEntityTypeShape(shape); shape.EntityType.SetRefName(_entity); shape.Width.Value = DEFAULTWIDTH; // The DSL will set the correct locations for the shapes at a later point, but we need to provide initial values for X and Y in the meantime // so that we can construct the shape. We're using random numbers here to ensure that if the DSL fails for some reason, new shapes do not // stack directly on top of each other. shape.PointX.Value = _rand.NextDouble() * 12.0; shape.PointY.Value = _rand.NextDouble() * 32.0; if (_fillColor != EntityDesignerDiagramConstant.EntityTypeShapeDefaultFillColor) { shape.FillColor.Value = _fillColor; } XmlModelHelper.NormalizeAndResolve(shape); _created = shape; } }
private static void UpdateMappingModel(EFArtifact existingArtifact, string oldStorageEntityContainerName) { // replaces the possible reference to the old S-side EntityContainer name ReplaceMappingContainerRef(existingArtifact, oldStorageEntityContainerName); // normalize and resolve the changes we just made above XmlModelHelper.NormalizeAndResolve(existingArtifact.MappingModel()); }
protected override void InvokeInternal(CommandProcessorContext cpc) { RetargetWithMetadataConverter(_artifact.XDocument, _targetSchemaVersion, MetadataConverterDriver.Instance); if (_reparseArtifact) { cpc.Artifact.Parse(new HashSet <XName>()); XmlModelHelper.NormalizeAndResolve(cpc.Artifact); } }
protected override void PostInvoke(CommandProcessorContext cpc) { // Normalize EFContainer if necessary foreach (var item in _efContainerToBeNormalized) { XmlModelHelper.NormalizeAndResolve(item); } base.PostInvoke(cpc); }
protected override void InvokeInternal(CommandProcessorContext cpc) { // don't do anything if we are trying to set the same thing if (string.Compare(Condition.ColumnName.RefName, NewStorageProperty.LocalName.Value, StringComparison.CurrentCulture) != 0) { Condition.ColumnName.SetRefName(NewStorageProperty); XmlModelHelper.NormalizeAndResolve(Condition); EnforceEntitySetMappingRules.AddRule(cpc, Condition); } }
protected override void InvokeInternal(CommandProcessorContext cpc) { var end = new EndProperty(AssociationSetMapping, null); end.Name.SetRefName(AssociationSetEnd); AssociationSetMapping.AddEndProperty(end); XmlModelHelper.NormalizeAndResolve(end); Debug.Assert(end.Name.Target != null, "Could not resolve AssociationSetEnd in an EndProperty"); _created = end; }
protected override void InvokeInternal(CommandProcessorContext cpc) { // if the OnDeleteAction already exists then only change the action value _createdAction = _parentEnd.OnDeleteAction; if (_createdAction == null) { _createdAction = new OnDeleteAction(_parentEnd, null); _parentEnd.OnDeleteAction = _createdAction; } _createdAction.Action.Value = _action; XmlModelHelper.NormalizeAndResolve(_createdAction); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var inheritanceConnector = new InheritanceConnector(_diagram, null); _diagram.AddInheritanceConnector(inheritanceConnector); inheritanceConnector.EntityType.SetRefName(_entity); XmlModelHelper.NormalizeAndResolve(inheritanceConnector); _created = inheritanceConnector; }
protected override void InvokeInternal(CommandProcessorContext cpc) { var associationConnector = new AssociationConnector(_diagram, null); _diagram.AddAssociationConnector(associationConnector); associationConnector.Association.SetRefName(_association); XmlModelHelper.NormalizeAndResolve(associationConnector); _created = associationConnector; }
protected override void InvokeInternal(CommandProcessorContext cpc) { // safety check, this should never be hit Debug.Assert(cpc != null, "InvokeInternal is called when EntityContainerMapping is null."); if (_ecm == null) { throw new InvalidOperationException("InvokeInternal is called when EntityContainerMapping is null."); } _ecm.GenerateUpdateViews.Value = _generateUpdateViews; XmlModelHelper.NormalizeAndResolve(_ecm); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var service = cpc.EditingContext.GetEFArtifactService(); var artifact = service.Artifact; // the model that we want to add the entity to var model = ModelHelper.GetEntityModel(artifact, ModelSpaceValue); if (model == null) { throw new CannotLocateParentItemException(); } // check for uniqueness if (UniquifyName) { Name = ModelHelper.GetUniqueName(typeof(EntityType), model, Name); } else { string msg = null; if (ModelHelper.IsUniqueName(typeof(EntityType), model, Name, false, out msg) == false) { throw new CommandValidationFailedException(msg); } } // create the new item in our model EntityType entity = null; if (model.IsCSDL) { entity = new ConceptualEntityType(model as ConceptualEntityModel, null); } else { entity = new StorageEntityType(model as StorageEntityModel, null); } Debug.Assert(entity != null, "entity should not be null"); if (entity == null) { throw new ItemCreationFailureException(); } // set the name, add it to the parent item entity.LocalName.Value = Name; model.AddEntityType(entity); XmlModelHelper.NormalizeAndResolve(entity); CreatedEntityType = entity; }
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; }
protected override void InvokeInternal(CommandProcessorContext cpc) { // we allow the command to set null _endpoints if needed. var navProp1 = new NavigationProperty(Entity, null); navProp1.LocalName.Value = Name; navProp1.Relationship.SetRefName(Association); navProp1.FromRole.SetRefName(FromEnd); navProp1.ToRole.SetRefName(ToEnd); Entity.AddNavigationProperty(navProp1); _createdNavigationProperty = navProp1; XmlModelHelper.NormalizeAndResolve(navProp1); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var cond = new Condition(_associationSetMapping, null); cond.ColumnName.SetRefName(_tableColumn); _associationSetMapping.AddCondition(cond); ModelHelper.SetConditionPredicate(cond, _isNull, _conditionValue); XmlModelHelper.NormalizeAndResolve(cond); _created = cond; }
private void BindToolbar() { if (this.MainToolbar.McToolbarItems.Count > 0) { this.MainToolbar.McToolbarItems.Clear(); } Toolbar toolbar = XmlModelHelper.GetToolbar(this.ViewName, this.PlaceName, this.ClassName); if (toolbar == null || toolbar.Items == null) { return; } this.BindFromObject(toolbar.Items, this.MainToolbar.McToolbarItems); }