internal void AddMissingEntityTypeShapes(EntityDesignArtifact efArtifact, out bool addedMissingShapes)
{
addedMissingShapes = false;
Debug.Assert(efArtifact != null, "EFArtifact is null");
if (efArtifact != null)
{
// Now, for all entitytypes, ensure that an entitytype shape is created.
var dslDiagram = Diagram as EntityDesignerDiagram;
if (efArtifact.ConceptualModel() != null
&& dslDiagram != null)
{
var entityTypesMaterializedAsShapes = new HashSet<Model.Entity.EntityType>();
foreach (
var designerEntityTypeShape in
efArtifact.DesignerInfo.Diagrams.Items.Where(d => d.Id.Value == DiagramId).SelectMany(d => d.EntityTypeShapes))
{
// First check if there's a ModelElement for this.
var entityTypeShape = dslDiagram.ModelElement.ModelXRef.GetExisting(designerEntityTypeShape) as EntityTypeShape;
if (entityTypeShape != null
&& designerEntityTypeShape.EntityType.Target != null
&& !entityTypesMaterializedAsShapes.Contains(designerEntityTypeShape.EntityType.Target))
{
entityTypesMaterializedAsShapes.Add(designerEntityTypeShape.EntityType.Target);
}
}
var cpc = new CommandProcessorContext(
efArtifact.EditingContext,
EfiTransactionOriginator.EntityDesignerOriginatorId,
"Restore Excluded Elements");
var cp = new CommandProcessor(cpc, shouldNotifyObservers: true);
foreach (var entityType in efArtifact.ConceptualModel().EntityTypes())
{
if (!entityTypesMaterializedAsShapes.Contains(entityType))
{
var modelDiagram = dslDiagram.ModelElement.ModelXRef.GetExisting(dslDiagram) as ModelDiagram;
if (modelDiagram != null)
{
cp.EnqueueCommand(new CreateEntityTypeShapeCommand(modelDiagram, entityType));
}
}
}
if (cp.CommandCount > 0)
{
cp.Invoke();
addedMissingShapes = true;
}
}
}
}
internal void AddMissingAssociationConnectors(EntityDesignArtifact efArtifact, out bool addedMissingShapes)
{
addedMissingShapes = false;
Debug.Assert(efArtifact != null, "EFArtifact is null");
if (efArtifact != null)
{
// Now, for all associations, ensure that an association connector is created.
var dslDiagram = Diagram as EntityDesignerDiagram;
if (efArtifact.ConceptualModel() != null
&& dslDiagram != null)
{
var associationsMaterializedAsConnectors = new HashSet<ModelAssociation>();
foreach (
var connector in
efArtifact.DesignerInfo.Diagrams.Items.Where(d => d.Id.Value == DiagramId)
.SelectMany(d => d.AssociationConnectors))
{
// First check if there's a ModelElement for this.
var associationConnector = dslDiagram.ModelElement.ModelXRef.GetExisting(connector) as AssociationConnector;
if (associationConnector != null
&& connector.Association.Target != null
&& !associationsMaterializedAsConnectors.Contains(connector.Association.Target))
{
associationsMaterializedAsConnectors.Add(connector.Association.Target);
}
}
var cpc = new CommandProcessorContext(
efArtifact.EditingContext,
EfiTransactionOriginator.EntityDesignerOriginatorId,
"Restore Excluded Elements");
var cp = new CommandProcessor(cpc, shouldNotifyObservers: true);
foreach (var association in efArtifact.ConceptualModel().Associations())
{
if (!associationsMaterializedAsConnectors.Contains(association))
{
var shouldAddConnector = true;
var entityTypesOnEnds = association.AssociationEnds().Select(ae => ae.Type.Target);
foreach (var entityType in entityTypesOnEnds)
{
if (entityType != null
&& entityType.GetAntiDependenciesOfType<Model.Designer.EntityTypeShape>()
.Any(ets => ets.Diagram.Id == DiagramId) == false)
{
shouldAddConnector = false;
break;
}
}
if (shouldAddConnector)
{
var modelDiagram = dslDiagram.ModelElement.ModelXRef.GetExisting(dslDiagram) as ModelDiagram;
if (modelDiagram != null)
{
cp.EnqueueCommand(new CreateAssociationConnectorCommand(modelDiagram, association));
}
}
}
}
if (cp.CommandCount > 0)
{
cp.Invoke();
addedMissingShapes = true;
}
}
}
}
internal static void UpdateModelFromDatabase(EntityDesignArtifact artifact)
{
VsUtils.EnsureProvider(artifact);
var serviceProvider = Services.ServiceProvider;
var project = VSHelpers.GetProjectForDocument(artifact.Uri.LocalPath, serviceProvider);
// set up ModelBuilderSettings for startMode=PerformDatabaseConfigAndSelectTables
ModelBuilderWizardForm.WizardMode startMode;
var settings =
SetupSettingsAndModeForDbPages(
serviceProvider, project, artifact, true,
ModelBuilderWizardForm.WizardMode.PerformDatabaseConfigAndSelectTables,
ModelBuilderWizardForm.WizardMode.PerformSelectTablesOnly, out startMode);
settings.WizardKind = WizardKind.UpdateModel;
// use existing storage namespace as new storage namespace
if (null != artifact.StorageModel()
&& null != artifact.StorageModel().Namespace
&& !string.IsNullOrEmpty(artifact.StorageModel().Namespace.Value))
{
settings.StorageNamespace = artifact.StorageModel().Namespace.Value;
}
// use existing model namespace as new model namespace (this only affects the temporary
// artifact but there is a situation where the C-side EntityContainer has been given the
// same name as the default model namespace where not setting this causes the temporary
// artifact to be unreadable because of symbol clashes)
if (null != artifact.ConceptualModel()
&& null != artifact.ConceptualModel().Namespace
&& !string.IsNullOrEmpty(artifact.ConceptualModel().Namespace.Value))
{
settings.ModelNamespace = artifact.ConceptualModel().Namespace.Value;
}
settings.ModelBuilderEngine = new UpdateModelFromDatabaseModelBuilderEngine();
// call the ModelBuilderWizardForm
var form = new ModelBuilderWizardForm(serviceProvider, settings, startMode);
try
{
form.Start();
}
catch (Exception e)
{
VsUtils.ShowErrorDialog(
string.Format(
CultureInfo.CurrentCulture,
Resources.ModelObjectItemWizard_UnexpectedExceptionHasOccurred,
e.Message));
return;
}
// if Wizard was cancelled or the user hit 'X' to close window
// no need for any further action
if (form.WizardCancelled
|| !form.WizardFinished)
{
return;
}
// Update the app. or web.config, register build providers etc
ConfigFileHelper.UpdateConfig(settings);
// use form.ModelBuilderSettings to look at accumulated info and
// take appropriate action
var editingContext = PackageManager.Package.DocumentFrameMgr.EditingContextManager.GetNewOrExistingContext(artifact.Uri);
var shouldReloadArtifact = ProcessAccumulatedInfo(editingContext, artifact, settings);
// If database was configured, add DbContext templates
if (startMode == ModelBuilderWizardForm.WizardMode.PerformDatabaseConfigAndSelectTables)
{
var edmxItem = VsUtils.GetProjectItemForDocument(artifact.Uri.LocalPath, serviceProvider);
new DbContextCodeGenerator().AddDbContextTemplates(edmxItem, settings.UseLegacyProvider);
}
// We can reload only after we added EF references to the project otherwise we would get a watermark
// saying that the schema version does not match the referenced EF version which would not be true.
// If we reload becuase there was an extension that potentially modified the artifact then it does not matter.
if (shouldReloadArtifact)
{
artifact.ReloadArtifact();
artifact.IsDirty = true;
}
}