Пример #1
0
        protected override void ClearErrorList(Uri oldUri, Uri newUri)
        {
            // clear out the error list so after the rename the errors are bound to the correct artifacts
            ErrorListHelper.ClearErrorsForDocAcrossLists(newUri);

            // for a save-as the errors are associated with the oldUri
            ErrorListHelper.ClearErrorsForDocAcrossLists(oldUri);
        }
Пример #2
0
 protected override void ClearErrorList(IVsHierarchy pHier, uint ItemID)
 {
     ErrorListHelper.ClearErrorsForDocAcrossLists(pHier, ItemID);
 }
        internal static void UpdateModelFromDatabase(EntityDesignArtifact artifact)
        {
            VsUtils.EnsureProvider(artifact);

            var project         = VSHelpers.GetProjectForDocument(artifact.Uri.LocalPath, PackageManager.Package);
            var serviceProvider = Services.ServiceProvider;

            // set up ModelBuilderSettings for startMode=PerformDatabaseConfigAndSelectTables
            ModelBuilderWizardForm.WizardMode startMode;
            ModelBuilderSettings settings;

            ModelBuilderEngine.SetupSettingsAndModeForDbPages(
                serviceProvider, project, artifact, true,
                ModelBuilderWizardForm.WizardMode.PerformDatabaseConfigAndSelectTables,
                ModelBuilderWizardForm.WizardMode.PerformSelectTablesOnly, out startMode, out settings);
            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
            ConfigFileUtils.UpdateConfig(settings);

            // clear all previous errors for this document first
            ErrorListHelper.ClearErrorsForDocAcrossLists(settings.Artifact.Uri);

            // log any errors that occurred during model-gen to the error list
            ErrorListHelper.LogUpdateModelWizardErrors(settings.ModelBuilderEngine.Errors, settings.Artifact.Uri.LocalPath);

            // 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;
            }
        }