/// <summary> /// Ensures the appropriate version of the specified packages are installed. If an existing version of the package /// already exists the following will happen: /// If a semantically compatible version already exists, no change is made to the package. /// If an older major version exists, a warning is logged and the package is upgraded. /// If an older minor/build version exists, an information message is logged and the package is upgraded. /// If a newer major version exists, a warning is logged and no change is made to the package. /// </summary> public static async Task InstallPackagesAsync( Dictionary<string, string> packages, string extensionId, ConnectedServiceLogger logger, Project project, IVsPackageInstallerServices packageInstallerServices, IVsPackageInstaller packageInstaller) { Dictionary<string, string> packagesToInstall = new Dictionary<string, string>(); await NuGetUtilities.InstallPackagesAsync( project, packages, (packageId, packageVersion) => { packagesToInstall.Add(packageId, packageVersion); return Task.FromResult<object>(null); }, logger, packageInstallerServices); if (packagesToInstall.Any()) { packageInstaller.InstallPackagesFromVSExtensionRepository(extensionId, false, false, project, packagesToInstall); } }
private bool IsPackageInstalled(Project project) { var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); return(installerServices.IsPackageInstalled(project, Constants.NUGET_ID)); }
// We have to access all members that we want to mock in advance, because Embed Interop Types is set to true against NuGet.VisualStudio. // See also the following issues: // * [A COM type can't make its mock by same procedure as usual. · Issue #215 · Moq-moq4](https://github.com/Moq/moq4/issues/215) // * [A COM type can't make its proxy by same procedure as usual. · Issue #117 · castleproject-Core](https://github.com/castleproject/Core/issues/117) static void Realize(IVsPackageInstallerServices installerServices) { installerServices.GetInstalledPackages(); installerServices.GetInstalledPackages(default(Project)); installerServices.IsPackageInstalled(default(Project), default(string)); installerServices.IsPackageInstalledEx(default(Project), default(string), default(string)); }
private void OnConfigureCompileOnBuildCommandInvoked(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); if (vs != null && vs.TryGetSelectedProject(out EnvDTE.Project project)) { IComponentModel componentModel = (IComponentModel)GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices nuget = componentModel.GetService <IVsPackageInstallerServices>(); IVsPackageInstaller installer = componentModel.GetService <IVsPackageInstaller>(); EnvDTE.StatusBar status = vs.StatusBar; if (!nuget.IsPackageInstalled(project, nameof(TSBuild))) { try { status.Text = $"{Symbol.Name}: installing {nameof(TSBuild)} package..."; status.Animate(true, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); installer.InstallPackage(null, project, nameof(TSBuild), Symbol.Version, false); } catch { status.Text = $"{Symbol.Name}: failed to install {nameof(TSBuild)}."; } finally { status.Animate(false, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); } } } }
/// <summary> /// Ensures the appropriate version of the specified packages are installed. If an existing version of the package /// already exists the following will happen: /// If a semantically compatible version already exists, no change is made to the package. /// If an older major version exists, a warning is logged and the package is upgraded. /// If an older minor/build version exists, an information message is logged and the package is upgraded. /// If a newer major version exists, a warning is logged and no change is made to the package. /// </summary> public static async Task InstallPackagesAsync( Dictionary <string, string> packages, string extensionId, ConnectedServiceLogger logger, Project project, IVsPackageInstallerServices packageInstallerServices, IVsPackageInstaller packageInstaller) { Dictionary <string, string> packagesToInstall = new Dictionary <string, string>(); await NuGetUtilities.InstallPackagesAsync( project, packages, (packageId, packageVersion) => { packagesToInstall.Add(packageId, packageVersion); return(Task.FromResult <object>(null)); }, logger, packageInstallerServices); if (packagesToInstall.Any()) { packageInstaller.InstallPackagesFromVSExtensionRepository(extensionId, false, false, project, packagesToInstall); } }
public VsTemplateWizard(IVsPackageInstaller installer, IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices, IOutputConsoleProvider consoleProvider) { _installer = installer; _websiteHandler = websiteHandler; _packageServices = packageServices; _consoleProvider = consoleProvider; }
//https://stackoverflow.com/questions/36143663/create-a-visual-studio-project-template-that-pulls-nuget-references-from-online public static void InstallPackages(Project project) { ProjectItem config = project.ProjectItems.Item("packages.init"); DTE dte = project.DTE; if (config == null && config.FileCount == 0) { return; } var path = config.FileNames[0]; WriteToOutput(dte, "Installing packages for " + project.Name); var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); var file = new PackageReferenceFile(path); foreach (PackageReference pRef in file.GetPackageReferences()) { if (!installerServices.IsPackageInstalled(project, pRef.Id)) { WriteToOutput(dte, String.Format("Installing {0}, version {1}", pRef.Id, pRef.Version.Version.ToString())); var installer = componentModel.GetService <IVsPackageInstaller>(); installer.InstallPackage( "All", project, pRef.Id, pRef.Version.Version, false); } } config.Delete(); }
public PackageServicesProxy(IVsPackageInstallerServices packageInstallerServices, IVsPackageInstaller packageInstaller, IVsPackageUninstaller packageUninstaller, IVsPackageSourceProvider packageSourceProvider) { _packageInstallerServices = packageInstallerServices; _packageInstaller = packageInstaller; _packageUninstaller = packageUninstaller; _packageSourceProvider = packageSourceProvider; }
private void OnInstallNugetPackageCommandInvoked(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); if (vs != null && vs.TryGetSelectedProject(out EnvDTE.Project project)) { IComponentModel componentModel = (IComponentModel)GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices nuget = componentModel.GetService <IVsPackageInstallerServices>(); IVsPackageInstaller installer = componentModel.GetService <IVsPackageInstaller>(); EnvDTE.StatusBar status = vs.StatusBar; if (!nuget.IsPackageInstalled(project, nameof(Sassin))) { try { status.Text = $"{Metadata.ProductName} installing {nameof(Sassin)}..."; status.Animate(true, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); installer.InstallPackage(null, project, nameof(Sassin), Convert.ToString(null), false); } catch { status.Text = $"{Metadata.ProductName} failed to install {nameof(Sassin)}."; } finally { status.Animate(false, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); } } } }
public static void InstallNuGetPackage(this IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, IStatusBar StatusBar, string packageName) { try { var version = NugetPackageVersionManager.GetVersionFromCacheForPackage(packageName); if (!String.IsNullOrEmpty(version)) { StatusBar.DisplayMessage(String.Format("Installing Package: {0} {1}...", packageName, version)); try { InstallNugetPackageForSpecifiedVersion(project, vsPackageInstaller, packageName, version); } catch (Exception installException) { StatusBar.DisplayMessage(String.Format("When attempting to install version {0} of the package {1}, the following error occured: {2}.. Going to now try installing the latest version of Package ...", version, packageName, installException.Message)); // There was a problem installing the specified version of the package. Try the installing the latest available package from the source. InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageName); } } else { StatusBar.DisplayMessage(String.Format("Installing the latest version of Package: {0}...", packageName)); InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageName); } StatusBar.DisplayMessage(""); } catch (Exception ex) { throw new Exception(String.Format("NuGet Package {0} cannot be installed ({1}).", packageName, ex.Message), ex); } }
public static string GetTargetFile() { string targetFile = string.Empty; try { var componentModel = (IComponentModel)CloudFoundryVisualStudioPackage.GetGlobalService(typeof(SComponentModel)); if (componentModel == null) { return(string.Empty); } IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); var packageDir = installerServices.GetInstalledPackages().Where(o => o.Id == CloudFoundryVisualStudioPackage.PackageId).FirstOrDefault().InstallPath; targetFile = System.IO.Path.Combine(packageDir, "cf-msbuild-tasks.targets"); } catch (Exception ex) { Logger.Error("Error retrieving nuget package service", ex); } return(targetFile); }
///////////////////////////////////////////////////////////////////////////// // Overridden Package Implementation #region Package Members /// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); packageInstaller = ComponentModel.GetService <IVsPackageInstaller>(); pkgInstallerServices = ComponentModel.GetService <IVsPackageInstallerServices>(); base.Initialize(); _outputWindow = new OutputWindowWriter(this, GuidList.guidServiceStackVSOutputWindowPane, "ServiceStackVS"); // Add our command handlers for menu (commands must exist in the .vsct file) OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (null != mcs) { // Create the command for the menu item. CommandID cSharpProjContextAddReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidServiceStackReference); var cSharpProjectContextOleMenuCommand = new OleMenuCommand(CSharpAddReferenceCallback, cSharpProjContextAddReferenceCommandId); cSharpProjectContextOleMenuCommand.BeforeQueryStatus += CSharpQueryAndAddMenuItem; mcs.AddCommand(cSharpProjectContextOleMenuCommand); CommandID fSharpProjContextAddReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidFSharpAddServiceStackReference); var fSharpProjectContextOleMenuCommand = new OleMenuCommand(FSharpAddReferenceCallback, fSharpProjContextAddReferenceCommandId); fSharpProjectContextOleMenuCommand.BeforeQueryStatus += FSharpQueryAndAddMenuItem; mcs.AddCommand(fSharpProjectContextOleMenuCommand); CommandID fSharpProjContextUpdateReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidFSharpUpdateServiceStackReference); var fSharpProjectContextUpdateOleMenuCommand = new OleMenuCommand(FSharpUpdateReferenceCallback, fSharpProjContextUpdateReferenceCommandId); fSharpProjectContextUpdateOleMenuCommand.BeforeQueryStatus += FSharpQueryAndAddUpdateMenuItem; mcs.AddCommand(fSharpProjectContextUpdateOleMenuCommand); } solutionEventsListener = new SolutionEventsListener(); solutionEventsListener.OnAfterOpenSolution += SolutionLoaded; }
private static IVsPackageInstallerServices GetInstallerServices(IServiceProvider package) { var componentModel = (IComponentModel)package.GetService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); return(installerServices); }
public ClientWizard(string clientKind, EnvDTE.Project project, IVsUIShell uiShell, IVsPackageInstaller packageInstaller, IVsPackageInstallerServices packageInstallerServices) { InitializeComponent(); _clientKind = clientKind; _dte = project.DTE; _project = project; _uiShell = uiShell; _packageInstaller = packageInstaller; _packageInstallerServices = packageInstallerServices; var edmxs = _dte.GetSolutionEdmx(_project).ToList(); edmx.ItemsSource = edmxs; edmx.SelectedItem = edmxs.FirstOrDefault(); var services = _dte.GetSolutionSvc(_project).ToList(); service.ItemsSource = services; service.SelectedItem = services.FirstOrDefault(); generationOptions.ItemsSource = new[] { GenerationOptions.GetViewModel(GenerationOptions.Kind.All), GenerationOptions.GetViewModel(GenerationOptions.Kind.WithoutGlobalWithoutFramework), GenerationOptions.GetViewModel(GenerationOptions.Kind.FrameworkOnly), GenerationOptions.GetViewModel(GenerationOptions.Kind.GlobalOnly) }; generationOptions.SelectedIndex = edmxs.Count == 0 || services.Count == 0 ? 2 : 0; if (!GenerationOptions.CanBeRunnedWithNoCopy(_dte)) { copyTemplates.IsChecked = true; copyTemplates.IsEnabled = false; } }
public VsPackageInstaller( ISourceRepositoryProvider sourceRepositoryProvider, Configuration.ISettings settings, IVsSolutionManager solutionManager, IVsPackageInstallerServices packageServices, IDeleteOnRestartManager deleteOnRestartManager) { _sourceRepositoryProvider = sourceRepositoryProvider; _settings = settings; _solutionManager = solutionManager; _packageServices = packageServices; _deleteOnRestartManager = deleteOnRestartManager; _isCPSJTFLoaded = false; _projectContext = new Lazy <INuGetProjectContext>(() => { var projectContext = new VSAPIProjectContext(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var logger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); return(projectContext); }); PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory); }
void SatifyDependencies() { if (solutionExplorer == null) { solutionExplorer = ServiceLocator.Global.GetExport <ISolutionExplorer>(); } if (platformProvider == null) { platformProvider = ServiceLocator.Global.GetExport <IPlatformProvider>(); } if (uiShell == null) { uiShell = ServiceLocator.Global.GetService <SVsUIShell, IVsUIShell>(); } if (packageInstaller == null) { packageInstaller = ServiceLocator.Global.GetExport <IVsPackageInstaller>(); } if (packageInstallerServices == null) { packageInstallerServices = ServiceLocator.Global.GetExport <IVsPackageInstallerServices>(); } }
private bool InstallTemplateBuilderPackage(Project project) { bool installedPkg = true; var dte = Package.GetGlobalService(typeof(DTE)) as DTE; try { var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); if (!installerServices.IsPackageInstalled(project, "TemplateBuilder")) { dte.StatusBar.Text = @"Installing TemplateBuilder NuGet package, this may take a minute..."; var installer = componentModel.GetService <IVsPackageInstaller>(); installer.InstallPackage(null, project, "TemplateBuilder", (System.Version)null, false); dte.StatusBar.Text = @"Finished installing the TemplateBuilder NuGet package"; } } catch (Exception ex) { installedPkg = false; dte.StatusBar.Text = @"Unable to install the TemplateBuilder NuGet package"; // Log the failure to the ActivityLog } return(installedPkg); }
public void ProjectFinishedGenerating(Project project) { //install packages, should revise var packageFile = project .ProjectItems .Item("xs.packages"); if (packageFile != null) { var packages = File.ReadAllLines(packageFile.FileNames[0]); foreach (var package in packages) { var info = package.Split(' '); if (info.Length != 2) { continue; //td: error } try { var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); var installer = componentModel.GetService <IVsPackageInstaller>(); installer.InstallPackage("All", project, info[0], info[1], false); } catch (Exception ex) { //td: error } } packageFile.Delete(); } }
private void InstallWebApiDependencies(Project proj, IVsPackageMetadata[] packs, IVsPackageInstaller installer, IVsPackageInstallerServices installerServices) { NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, NewtonsoftJsonPackageId, NewtonsoftJsonPackageVersion, Settings.Default.NugetExternalPackagesSource); NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, EdgePackageId, EdgePackageVersion, Settings.Default.NugetExternalPackagesSource); NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, "System.ComponentModel.Annotations", "4.0.0", Settings.Default.NugetExternalPackagesSource); // RAML.Parser if (!installerServices.IsPackageInstalled(proj, "RAML.Parser.Model")) { installer.InstallPackage(NugetPackagesSource, proj, "RAML.Parser.Model", "1.0.7", false); } // AMF.Api.Core if (!installerServices.IsPackageInstalled(proj, RamlApiCorePackageId)) { //installer.InstallPackage(nugetPackagesSource, proj, ramlApiCorePackageId, ramlApiCorePackageVersion, false); installer.InstallPackage(NugetPackagesSource, proj, RamlApiCorePackageId, RamlApiCorePackageVersion, false); } // AMF.WebApiExplorer if (!installerServices.IsPackageInstalled(proj, RamlWebApiExplorerPackageId)) { installer.InstallPackage(NugetPackagesSource, proj, RamlWebApiExplorerPackageId, RamlWebApiExplorerPackageVersion, false); } }
private void MenuItem_BeforeQueryStatus(object sender, EventArgs e) { OleMenuCommand commandInfo = sender as OleMenuCommand; if (commandInfo != null) { DTE dte = (DTE)GetService(typeof(DTE)); var componentModel = (IComponentModel)GetService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); dte.Windows.Item(EnvDTE.Constants.vsWindowKindSolutionExplorer).Activate(); if (installerServices.GetInstalledPackages().Where(o => o.Id == PackageId).FirstOrDefault() == null) { commandInfo.Visible = false; } else { commandInfo.Visible = true; commandInfo.Text = "Publish to Cloud Foundry"; } } }
public VsTemplateWizard( IVsPackageInstaller installer, #pragma warning disable CS0618 // Type or member is obsolete IVsPackageInstallerServices packageServices, #pragma warning restore CS0618 // Type or member is obsolete IOutputConsoleProvider consoleProvider, IVsSolutionManager solutionManager, Configuration.ISettings settings, ISourceRepositoryProvider sourceProvider, IVsProjectAdapterProvider vsProjectAdapterProvider ) { _installer = installer; _packageServices = packageServices; _consoleProvider = consoleProvider; _solutionManager = solutionManager; _settings = settings; _sourceProvider = sourceProvider; _vsProjectAdapterProvider = vsProjectAdapterProvider; _preinstalledPackageInstaller = new Lazy <PreinstalledPackageInstaller>(() => { return(new PreinstalledPackageInstaller(_packageServices, _solutionManager, _settings, _sourceProvider, (VsPackageInstaller)_installer, _vsProjectAdapterProvider)); }); PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory); }
private ILookup<string, FileSystemPath> installedPackages; // there can be several versions of one package (different versions) #endregion Fields #region Constructors public NuGetApi(ISolution solution, Lifetime lifetime, IComponentModel componentModel, IThreading threading, ProjectModelSynchronizer projectModelSynchronizer) { this.solution = solution; this.threading = threading; this.projectModelSynchronizer = projectModelSynchronizer; try { vsPackageInstallerServices = componentModel.GetExtensions<IVsPackageInstallerServices>().SingleOrDefault(); vsPackageInstaller = componentModel.GetExtensions<IVsPackageInstaller>().SingleOrDefault(); vsPackageInstallerEvents = componentModel.GetExtensions<IVsPackageInstallerEvents>().SingleOrDefault(); } catch (Exception e) { Logger.LogException("Unable to get NuGet interfaces.", e); } if (!IsNuGetAvailable) { Logger.LogMessage(LoggingLevel.VERBOSE, "[NUGET PLUGIN] Unable to get NuGet interfaces. No exception thrown"); return; } lifetime.AddBracket( () => vsPackageInstallerEvents.PackageInstalled += RecalcInstalledPackages, () => vsPackageInstallerEvents.PackageInstalled -= RecalcInstalledPackages); lifetime.AddBracket( () => vsPackageInstallerEvents.PackageUninstalled += RecalcInstalledPackages, () => vsPackageInstallerEvents.PackageUninstalled -= RecalcInstalledPackages); RecalcInstalledPackages(null); }
public VsPackageInstaller(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager, IVsPackageInstallerServices packageServices) { _sourceRepositoryProvider = sourceRepositoryProvider; _settings = settings; _solutionManager = solutionManager; _projectContext = new VSAPIProjectContext(); _packageServices = packageServices; }
protected override void RemoveDependencies(Project proj, IVsPackageInstallerServices installerServices, IVsPackageUninstaller installer) { // AMF.NetCoreApiExplorer if (installerServices.IsPackageInstalled(proj, RamlNetCoreApiExplorerPackageId)) { installer.UninstallPackage(proj, RamlNetCoreApiExplorerPackageId, false); } }
public void GetService_GetIVsPackageInstallerServices_ReturnsVsPackageInstallerServices() { CreateComponentModel(); IVsPackageInstallerServices installer = model.GetService <IVsPackageInstallerServices>(); Assert.IsNotNull(installer); }
/// <summary> /// Gets the package metatdata installed for the given project /// </summary> /// <param name="proj"></param> /// <returns></returns> private static IVsPackageMetadata GetInstalledPackageMetadata(Project proj) { IComponentModel componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); IEnumerable <IVsPackageMetadata> packages = installerServices.GetInstalledPackages(proj); return(packages.Where(pkg => pkg.Id == TypeRightPackage.NugetID).FirstOrDefault()); }
public VsProjectScope(string id, Project project, IIdeScope ideScope, IVsPackageInstallerServices vsPackageInstallerServices) { _project = project; _vsPackageInstallerServices = vsPackageInstallerServices; IdeScope = ideScope; ProjectFolder = VsUtils.GetProjectFolder(project); ProjectName = project.Name; Debug.Assert(ProjectFolder != null, "VsxHelper.IsSolutionProject ensures a not-null ProjectFolder"); }
public PackageHandler(EnvDTE.Project project, IVsPackageInstallerServices packageServices, IVsPackageInstaller installer, IVsPackageUninstaller uninstaller, IVsPackageInstallerEvents events) : this(project, packageServices, installer, uninstaller, events, null) { m_project = project; m_packageServices = packageServices; m_installer = installer; m_uninstaller = uninstaller; m_events = events; }
/// <summary> /// Initializes the package installer services /// </summary> public void Init() { var componentModel = (IComponentModel)Shell.Package.GetGlobalService(typeof(SComponentModel)); if (componentModel != null) { this.PackageInstallerServices = componentModel.GetService <IVsPackageInstallerServices>(); this.PackageInstaller = componentModel.GetService <IVsPackageInstaller>(); } }
public PackageServices() { var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); _PkgInstaller = componentModel.GetService <IVsPackageInstaller2>(); _PkgService = componentModel.GetService <IVsPackageInstallerServices>(); _PkgRepos = componentModel.GetService <IVsPackageSourceProvider>(); _PkgUninstaller = componentModel.GetService <IVsPackageUninstaller>(); _PkgRestorer = componentModel.GetService <IVsPackageRestorer>(); }
public PreinstalledPackageInstaller( IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices, IVsCommonOperations vsCommonOperations, ISolutionManager solutionManager) { _websiteHandler = websiteHandler; _packageServices = packageServices; _vsCommonOperations = vsCommonOperations; _solutionManager = solutionManager; }
private void InitPackageHelper() { var componentModel = (IComponentModel)GetService(typeof(SComponentModel)); IVsPackageInstallerServices installerServices = componentModel.GetService <IVsPackageInstallerServices>(); PackageHelper.PackageInstallerServices = installerServices; PackageHelper.PackageInstaller = componentModel.GetService <IVsPackageInstaller2>(); var nugetEvents = componentModel.GetService <IVsPackageInstallerEvents>(); nugetEvents.PackageInstalled += NugetEvents_PackageInstalled; }
/// <summary> /// Creates an instance of the package installer for unit testing of registry-based preinstalled packages. This should only be used for unit tests. /// </summary> /// <param name="registryKeys">The optional list of parent registry keys to look in (used for unit tests).</param> internal VsPackageInstaller(IVsPackageManagerFactory packageManagerFactory, IScriptExecutor scriptExecutor, IPackageRepositoryFactory repositoryFactory, IOutputConsoleProvider consoleProvider, IVsCommonOperations vsCommonOperations, ISolutionManager solutionManager, IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices, IEnumerable<IRegistryKey> registryKeys) : this(packageManagerFactory, scriptExecutor, repositoryFactory, consoleProvider, vsCommonOperations, solutionManager, websiteHandler, packageServices) { _registryKeys = registryKeys; }
/// <summary> /// Creates an instance of the package installer for unit testing of extension-based preinstalled packages. This should only be used for unit tests. /// </summary> /// <param name="vsExtensionManager">A mock extension manager instance (used for unit tests).</param> internal VsPackageInstaller(IVsPackageManagerFactory packageManagerFactory, IScriptExecutor scriptExecutor, IPackageRepositoryFactory repositoryFactory, IOutputConsoleProvider consoleProvider, IVsCommonOperations vsCommonOperations, ISolutionManager solutionManager, IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices, object vsExtensionManager) : this(packageManagerFactory, scriptExecutor, repositoryFactory, consoleProvider, vsCommonOperations, solutionManager, websiteHandler, packageServices) { _vsExtensionManager = vsExtensionManager; }
public PreinstalledPackageInstaller( IVsPackageInstallerServices packageServices, ISolutionManager solutionManager, ISettings settings, ISourceRepositoryProvider sourceProvider, VsPackageInstaller installer) { //_websiteHandler = websiteHandler; _packageServices = packageServices; //_vsCommonOperations = vsCommonOperations; _solutionManager = solutionManager; _sourceProvider = sourceProvider; _installer = installer; }
public static void InstallPackage(this IVsPackageInstaller packageInstaller, Project project, string packageName, IVsPackageInstallerServices packageInstallerServices, string version = null) { if (version == null) { version = new V2FeedContext(new Uri("http://www.nuget.org/api/v2/")).Execute<V2FeedPackage>(new Uri("http://www.nuget.org/api/v2/Packages?$filter=IsAbsoluteLatestVersion and Id eq '" + packageName + "'&$skip=0&$top=1&$select=Id,Version&targetFramework=&includePrerelease=true")).Single().Version; } packageInstaller.InstallPackage("http://packages.nuget.org", project, packageName, version, false); //workaround to the bug on Package installer that does not install package depencences var dependencies = new LocalPackageRepository(packageInstallerServices.GetPackageLocation(packageName)).FindPackage(packageName).DependencySets.SelectMany(ds => ds.Dependencies); foreach (var dependency in dependencies) { InstallPackage(packageInstaller, project, dependency.Id, packageInstallerServices, dependency.VersionSpec.ToString()); } }
public VsTemplateWizard( IVsPackageInstaller installer, IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices, IOutputConsoleProvider consoleProvider, IVsCommonOperations vsCommonOperations, ISolutionManager solutionManager) { _installer = installer; _websiteHandler = websiteHandler; _packageServices = packageServices; _consoleProvider = consoleProvider; _vsCommonOperations = vsCommonOperations; _solutionManager = solutionManager; }
public ViewModelWizard(EnvDTE.DTE dte, EnvDTE.ProjectItem viewModel, IVsPackageInstallerServices packageInstallerServices) { InitializeComponent(); _dte = dte; _viewModel = viewModel; _packageInstallerServices = packageInstallerServices; var edmxs = _dte.GetSolutionEdmx(_viewModel.ContainingProject, skipWaqsAlreadyUsed: false).ToList(); edmx.ItemsSource = edmxs; edmx.SelectedItem = edmxs.FirstOrDefault(); var views = _dte.GetSolutionXaml(_viewModel.ContainingProject).ToList(); views.Insert(0, new DTEExtensions.FilePathes { DisplayPath = "", FullPath = null }); view.ItemsSource = views; view.SelectedItem = views.FirstOrDefault(); }
public VsTemplateWizard( IVsPackageInstaller installer, IVsPackageInstallerServices packageServices, IOutputConsoleProvider consoleProvider, ISolutionManager solutionManager, ISettings settings, ISourceRepositoryProvider sourceProvider ) { _installer = installer; _packageServices = packageServices; _consoleProvider = consoleProvider; _solutionManager = solutionManager; _settings = settings; _sourceProvider = sourceProvider; _preinstalledPackageInstaller = new PreinstalledPackageInstaller(_packageServices, _solutionManager, _settings, _sourceProvider, (VsPackageInstaller)_installer); }
public VsPackageInstaller(IVsPackageManagerFactory packageManagerFactory, IScriptExecutor scriptExecutor, IPackageRepositoryFactory repositoryFactory, IOutputConsoleProvider consoleProvider, IVsCommonOperations vsCommonOperations, ISolutionManager solutionManager, IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices) { _packageManagerFactory = packageManagerFactory; _scriptExecutor = scriptExecutor; _repositoryFactory = repositoryFactory; _consoleProvider = consoleProvider; _vsCommonOperations = vsCommonOperations; _solutionManager = solutionManager; _websiteHandler = websiteHandler; _packageServices = packageServices; }
public ServerWizard(EnvDTE.Project project, IVsUIShell uiShell, IVsPackageInstaller packageInstaller, IVsPackageInstallerServices packageInstallerServices) { InitializeComponent(); _dte = project.DTE; _project = project; _uiShell = uiShell; _packageInstaller = packageInstaller; _packageInstallerServices = packageInstallerServices; var edmxs = _dte.GetSolutionEdmx(_project).ToList(); edmx.ItemsSource = edmxs; edmx.SelectedItem = edmxs.FirstOrDefault(); generationOptions.ItemsSource = new[] { GenerationOptions.GetViewModel(GenerationOptions.Kind.All), GenerationOptions.GetViewModel(GenerationOptions.Kind.WithoutGlobalWithoutFramework), GenerationOptions.GetViewModel(GenerationOptions.Kind.FrameworkOnly), GenerationOptions.GetViewModel(GenerationOptions.Kind.GlobalOnly) }; generationOptions.SelectedIndex = edmxs.Count == 0 ? 2 : 0; if (! GenerationOptions.CanBeRunnedWithNoCopy(_dte)) { copyTemplates.IsChecked = true; copyTemplates.IsEnabled = false; } }
/// <summary> /// Uninstall the packages that exist in the project. /// </summary> public static async Task UninstallPackagesAsync( Project targetProject, ISet<string> packages, Func<string, Task> uninstallPackage, ConnectedServiceLogger logger, IVsPackageInstallerServices packageInstallerServices) { IEnumerable<IVsPackageMetadata> installedPackages = packageInstallerServices.GetInstalledPackages(targetProject); foreach (string packageId in packages) { IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == packageId); if (installedPackage != null) { await logger.WriteMessageAsync( LoggerMessageCategory.Information, Resource.LogMessage_RemovingNuGetPackage, packageId, installedPackage.VersionString); await uninstallPackage(packageId); } } }
public TestableVsTemplateWizard( IVsPackageInstaller installer = null, Func<string, XDocument> loadDocumentCallback = null, IVsWebsiteHandler websiteHandler = null, IVsPackageInstallerServices packageServices = null, IOutputConsoleProvider consoleProvider = null) : base( installer, websiteHandler, packageServices ?? new Mock<IVsPackageInstallerServices>().Object, consoleProvider ?? new Mock<IOutputConsoleProvider>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object) { ErrorMessages = new List<string>(); _loadDocumentCallback = loadDocumentCallback ?? (path => null); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { Debug.WriteLine (string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); packageInstaller = ComponentModel.GetService<IVsPackageInstaller>(); pkgInstallerServices = ComponentModel.GetService<IVsPackageInstallerServices>(); base.Initialize(); // Add our command handlers for menu (commands must exist in the .vsct file) var mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if ( null != mcs ) { // Create the command for the menu item. var cSharpProjContextAddReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidCSharpAddServiceStackReference); var cSharpProjectAddReferenceMenuCommand = new OleMenuCommand(CSharpAddReferenceCallback ,cSharpProjContextAddReferenceCommandId); cSharpProjectAddReferenceMenuCommand.BeforeQueryStatus += CSharpQueryAddMenuItem; mcs.AddCommand(cSharpProjectAddReferenceMenuCommand); var fSharpProjContextAddReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidFSharpAddServiceStackReference); var fSharpProjectContextOleMenuCommand = new OleMenuCommand(FSharpAddReferenceCallback, fSharpProjContextAddReferenceCommandId); fSharpProjectContextOleMenuCommand.BeforeQueryStatus += FSharpQueryAddMenuItem; mcs.AddCommand(fSharpProjectContextOleMenuCommand); var vbNetProjContextAddReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidVbNetAddServiceStackReference); var vbNetProjectContextOleMenuCommand = new OleMenuCommand(VbNetAddReferenceCallback, vbNetProjContextAddReferenceCommandId); vbNetProjectContextOleMenuCommand.BeforeQueryStatus += VbNetQueryAddMenuItem; mcs.AddCommand(vbNetProjectContextOleMenuCommand); var typeScriptProjContextAddReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidTypeScriptAddServiceStackReference); var typeScriptProjectContextOleMenuCommand = new OleMenuCommand(TypeScriptAddReferenceCallback, typeScriptProjContextAddReferenceCommandId); typeScriptProjectContextOleMenuCommand.BeforeQueryStatus += TypeScriptQueryAddMenuItem; mcs.AddCommand(typeScriptProjectContextOleMenuCommand); var updateReferenceCommandId = new CommandID(GuidList.guidVSServiceStackCmdSet, (int)PkgCmdIDList.cmdidUpdateServiceStackReference); var updateReferenceMenuCommand = new OleMenuCommand(UpdateReferenceCallback, updateReferenceCommandId); updateReferenceMenuCommand.BeforeQueryStatus += QueryUpdateMenuItem; mcs.AddCommand(updateReferenceMenuCommand); } solutionEventsListener = new SolutionEventsListener(); solutionEventsListener.OnAfterOpenSolution += SolutionLoaded; }
public static void InstallNuGetPackage(this IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, IStatusBar StatusBar, string packageName, string targetNsbVersion) { string packageId; int? majorVersion; GetPackageIdAndMajorVersion(packageName, targetNsbVersion, out packageId, out majorVersion); try { var version = NugetPackageVersionManager.GetVersionFromCacheForPackage(packageId, majorVersion); if (!String.IsNullOrEmpty(version)) { StatusBar.DisplayMessage(String.Format("Installing Package: {0} {1}...", packageId, version)); try { InstallNugetPackageForSpecifiedVersion(project, vsPackageInstaller, packageId, version); } catch (Exception installException) { StatusBar.DisplayMessage(String.Format("When attempting to install version {0} of the package {1}, the following error occured: {2}.. Going to now try installing the latest version of Package ...", version, packageId, installException.Message)); // There was a problem installing the specified version of the package. Try the installing the latest available package from the source. InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageId, majorVersion); } } else { StatusBar.DisplayMessage(String.Format("Installing the latest version of Package: {0}...", packageId)); InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageId, majorVersion); } } catch (Exception ex) { throw new Exception(String.Format("NuGet Package {0} cannot be installed ({1}).", packageId, ex.Message), ex); } finally { StatusBar.DisplayMessage(""); } }
private void StartWorker() { var componentModel = _workspace.GetVsService<SComponentModel, IComponentModel>(); _packageInstallerServices = componentModel.GetExtensions<IVsPackageInstallerServices>().FirstOrDefault(); _packageInstaller = componentModel.GetExtensions<IVsPackageInstaller>().FirstOrDefault(); _packageUninstaller = componentModel.GetExtensions<IVsPackageUninstaller>().FirstOrDefault(); _packageSourceProvider = componentModel.GetExtensions<IVsPackageSourceProvider>().FirstOrDefault(); if (!this.IsEnabled) { return; } // Start listening to workspace changes. _workspace.WorkspaceChanged += OnWorkspaceChanged; _packageSourceProvider.SourcesChanged += OnSourceProviderSourcesChanged; OnSourceProviderSourcesChanged(null, EventArgs.Empty); }
public static void InstallNugetPackageForSpecifiedVersion(this IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, IStatusBar StatusBar, string packageName, string version) { try { StatusBar.DisplayMessage(String.Format("Installing Package: {0} {1}...", packageName, version)); try { InstallNugetPackageForSpecifiedVersion(project, vsPackageInstaller, packageName, version); } catch (Exception installException) { StatusBar.DisplayMessage(String.Format("When attempting to install version {0} of the package {1}, the following error occured: {2}.. Going to now try installing the latest version of Package ...", version, packageName, installException.Message)); } } catch (Exception ex) { throw new Exception(String.Format("NuGet Package {0} cannot be installed ({1}).", packageName, ex.Message), ex); } finally { StatusBar.DisplayMessage(""); } }
private static void InstallLatestNugetPackage(IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageId, int? majorVersion) { // lookup latest version for the given major (or null), and install that var latestVersion = GetLatestVersionForMajor(packageId, majorVersion); vsPackageInstaller.InstallPackage( ServiceMatrixOverrides.GetNugetFeedServiceBaseAddress() ?? "All", project.As<EnvDTE.Project>(), packageId, latestVersion, false); // Call the installed packages to get the version that was just installed and cache the version. // Packages are needed in case latestVersion is null, var installedPackages = vsPackageInstallerServices.GetInstalledPackages(); NugetPackageVersionManager.UpdateCache(packageId, majorVersion, installedPackages); }
/// <summary> /// Ensures the appropriate version of the specified packages are installed. If an existing version of the package /// already exists the following will happen: /// If a semantically compatible version already exists, no change is made to the package. /// If an older major version exists, a warning is logged and the package is upgraded. /// If an older minor/build version exists, an information message is logged and the package is upgraded. /// If a newer major version exists, a warning is logged and no change is made to the package. /// </summary> public static async Task InstallPackagesAsync( Project targetProject, Dictionary<string, string> packages, Func<string, string, Task> installPackage, ConnectedServiceLogger logger, IVsPackageInstallerServices packageInstallerServices) { IEnumerable<IVsPackageMetadata> installedPackages; try { installedPackages = packageInstallerServices.GetInstalledPackages(targetProject); } catch (ArgumentException) { // This happens for C++ projects installedPackages = new List<IVsPackageMetadata>(); } foreach (KeyValuePair<string, string> requiredPackage in packages) { IVsPackageMetadata installedPackage = installedPackages.FirstOrDefault(p => p.Id == requiredPackage.Key); if (installedPackage == null) { // The package does not exist - notify and install the package. await logger.WriteMessageAsync( LoggerMessageCategory.Information, Resource.LogMessage_AddingNuGetPackage, requiredPackage.Key, requiredPackage.Value); } else { Version installedVersion = NuGetUtilities.GetVersion(installedPackage.VersionString); Version requiredVersion = NuGetUtilities.GetVersion(requiredPackage.Value); if (installedVersion == null || requiredVersion == null) { // Unable to parse the version - continue. continue; } else if (installedVersion.Major < requiredVersion.Major) { // An older potentially non-compatible version of the package already exists - warn and upgrade the package. await logger.WriteMessageAsync( LoggerMessageCategory.Warning, Resource.LogMessage_OlderMajorVersionNuGetPackageExists, requiredPackage.Key, installedPackage.VersionString, requiredPackage.Value); } else if (installedVersion.Major > requiredVersion.Major) { // A newer potentially non-compatible version of the package already exists - warn and continue. await logger.WriteMessageAsync( LoggerMessageCategory.Warning, Resource.LogMessage_NewerMajorVersionNuGetPackageExists, requiredPackage.Key, requiredPackage.Value, installedPackage.VersionString); continue; } else if (installedVersion >= requiredVersion) { // A semantically compatible version of the package already exists - continue. continue; } else { // An older semantically compatible version of the package exists - notify and upgrade the package. await logger.WriteMessageAsync( LoggerMessageCategory.Information, Resource.LogMessage_UpgradingNuGetPackage, requiredPackage.Key, installedPackage.VersionString, requiredPackage.Value); } } await installPackage(requiredPackage.Key, requiredPackage.Value); } }
private static void InstallLatestNugetPackage(IProject project,IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageName) { vsPackageInstaller.InstallPackage("All", project.As<EnvDTE.Project>(), packageName, (Version)null, false); // Call the installed packages to get the version that was just installed and cache the version. var installedPackages = vsPackageInstallerServices.GetInstalledPackages(); NugetPackageVersionManager.UpdateCache(packageName, installedPackages); }