/// <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, IVsWebsiteHandler websiteHandler, IVsPackageInstallerServices packageServices, IOutputConsoleProvider consoleProvider)
{
_installer = installer;
_websiteHandler = websiteHandler;
_packageServices = packageServices;
_consoleProvider = consoleProvider;
}
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;
}
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;
}
public PreinstalledPackageInstaller(
IVsWebsiteHandler websiteHandler,
IVsPackageInstallerServices packageServices,
IVsCommonOperations vsCommonOperations,
ISolutionManager solutionManager)
{
_websiteHandler = websiteHandler;
_packageServices = packageServices;
_vsCommonOperations = vsCommonOperations;
_solutionManager = solutionManager;
}
/// <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);
}
// 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));
}
public PackageServicesProxy(IVsPackageInstallerServices packageInstallerServices, IVsPackageInstaller packageInstaller, IVsPackageUninstaller packageUninstaller, IVsPackageSourceProvider packageSourceProvider)
{
_packageInstallerServices = packageInstallerServices;
_packageInstaller = packageInstaller;
_packageUninstaller = packageUninstaller;
_packageSourceProvider = packageSourceProvider;
}
/// <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);
}
