private async Task ExecuteAsync(object sender, EventArgs e)
{
Telemetry.TrackUserTask("Execute-RestoreSolutionCommand");
var solution = (IVsSolution)ServiceProvider.GetService(typeof(SVsSolution));
IEnumerable <IVsHierarchy> hierarchies = VsHelpers.GetProjectsInSolution(solution, __VSENUMPROJFLAGS.EPF_LOADEDINSOLUTION);
var configFiles = new List <string>();
foreach (IVsHierarchy hierarchy in hierarchies)
{
Project project = VsHelpers.GetDTEProject(hierarchy);
if (await VsHelpers.ProjectContainsManifestFileAsync(project))
{
string rootPath = await project.GetRootFolderAsync();
string configFilePath = Path.Combine(rootPath, Constants.ConfigFileName);
configFiles.Add(configFilePath);
}
}
await _libraryCommandService.RestoreAsync(configFiles, CancellationToken.None);
}
public static async Task CleanAsync(ProjectItem configProjectItem)
{
Logger.LogEvent(Resources.Text.CleanLibrariesStarted, LogLevel.Task);
string configFileName = configProjectItem.FileNames[1];
var dependencies = Dependencies.FromConfigFile(configFileName);
Manifest manifest = await Manifest.FromFileAsync(configFileName, dependencies, CancellationToken.None).ConfigureAwait(false);
var hostInteraction = dependencies.GetHostInteractions() as HostInteraction;
IEnumerable <ILibraryInstallationResult> results = manifest?.Clean((file) => hostInteraction.DeleteFiles(file));
if (results != null && results.All(r => r.Success))
{
Logger.LogEvent(Resources.Text.CleanLibrariesSucceeded + Environment.NewLine, LogLevel.Task);
Telemetry.TrackUserTask("clean", TelemetryResult.Success, new KeyValuePair <string, object>("librariesdeleted", results.Count()));
}
else
{
Logger.LogEvent(Resources.Text.CleanLibrariesFailed + Environment.NewLine, LogLevel.Task);
Telemetry.TrackUserTask("clean", TelemetryResult.Failure, new KeyValuePair <string, object>("librariesfailedtodelete", results.Where(r => !r.Success).Count()));
}
}
public override void Invoke(CancellationToken cancellationToken)
{
Telemetry.TrackUserTask("Invoke-UpdateSuggestedAction");
if (_disabled)
{
return;
}
try
{
var dependencies = Dependencies.FromConfigFile(_provider.ConfigFilePath);
IProvider provider = dependencies.GetProvider(_provider.InstallationState.ProviderId);
ILibraryCatalog catalog = provider?.GetCatalog();
if (catalog == null)
{
return;
}
JSONMember member = _provider.LibraryObject.Children.OfType <JSONMember>().FirstOrDefault(m => m.UnquotedNameText == ManifestConstants.Library);
if (member != null)
{
using (ITextEdit edit = TextBuffer.CreateEdit())
{
edit.Replace(new Span(member.Value.Start, member.Value.Length), "\"" + _updatedLibraryId + "\"");
edit.Apply();
}
}
}
catch (Exception ex)
{
Logger.LogEvent(ex.ToString(), LogLevel.Error);
Telemetry.TrackException("UpdateSuggestedActionFailed", ex);
}
}
private async Task UninstallLibraryAsync(string configFilePath, string libraryId, CancellationToken cancellationToken)
{
Logger.LogEventsHeader(OperationType.Uninstall, libraryId);
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
var dependencies = Dependencies.FromConfigFile(configFilePath);
Manifest manifest = await Manifest.FromFileAsync(configFilePath, dependencies, cancellationToken).ConfigureAwait(false);
ILibraryOperationResult result = null;
if (manifest == null)
{
result = LibraryOperationResult.FromError(PredefinedErrors.ManifestMalformed());
}
else
{
IHostInteraction hostInteraction = dependencies.GetHostInteractions();
result = await manifest.UninstallAsync(libraryId, async (filesPaths) => await hostInteraction.DeleteFilesAsync(filesPaths, cancellationToken), cancellationToken).ConfigureAwait(false);
}
sw.Stop();
Logger.LogEventsSummary(new List <ILibraryOperationResult> {
result
}, OperationType.Uninstall, sw.Elapsed);
Telemetry.TrackUserTask("libraryuninstall");
}
catch (OperationCanceledException)
{
Logger.LogEvent(string.Format(LibraryManager.Resources.Text.Uninstall_LibraryCancelled, libraryId), LogLevel.Task);
}
}
public override async void Invoke(CancellationToken cancellationToken)
{
try
{
Telemetry.TrackUserTask("Invoke-UninstallFromSuggestedAction");
var state = _provider.InstallationState;
await _libraryCommandService.UninstallAsync(_provider.ConfigFilePath, state.Name, state.Version, state.ProviderId, cancellationToken)
.ConfigureAwait(false);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
using (ITextEdit edit = TextBuffer.CreateEdit())
{
var arrayElement = _provider.LibraryObject.Parent as ArrayElementNode;
var prev = GetPreviousSibling(arrayElement) as ArrayElementNode;
var next = GetNextSibling(arrayElement) as ArrayElementNode;
int start = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.Start).Start;
int end = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.End).EndIncludingLineBreak;
if (next == null && prev?.Comma != null)
{
start = prev.Comma.Start;
end = TextBuffer.CurrentSnapshot.GetLineFromPosition(arrayElement.End).End;
}
edit.Delete(Span.FromBounds(start, end));
edit.Apply();
}
}
catch (Exception ex)
{
Logger.LogEvent(ex.ToString(), LibraryManager.Contracts.LogLevel.Error);
Telemetry.TrackException("UninstallFromSuggestedActionFailed", ex);
}
}
protected override IEnumerable <JSONCompletionEntry> GetEntries(JSONCompletionContext context)
{
var member = context.ContextItem as JSONMember;
if (member == null || (member.UnquotedNameText != ManifestConstants.Provider && member.UnquotedNameText != ManifestConstants.DefaultProvider))
{
yield break;
}
var dependencies = Dependencies.FromConfigFile(ConfigFilePath);
IEnumerable <string> providerIds = dependencies.Providers?.Select(p => p.Id);
if (providerIds == null || !providerIds.Any())
{
yield break;
}
foreach (string id in providerIds)
{
yield return(new SimpleCompletionEntry(id, _libraryIcon, context.Session));
}
Telemetry.TrackUserTask("completionprovider");
}
private async Task ExecuteAsync(object sender, EventArgs e)
{
ProjectItem projectItem = await VsHelpers.GetSelectedItemAsync();
Project project = await VsHelpers.GetProjectOfSelectedItemAsync();
try
{
var dependencies = _dependenciesFactory.FromConfigFile(projectItem.FileNames[1]);
IEnumerable <string> packageIds = dependencies.Providers
.Where(p => p.NuGetPackageId != null)
.Select(p => p.NuGetPackageId)
.Distinct();
if (!_isPackageInstalled)
{
if (!UserWantsToInstall())
{
return;
}
await Task.Run(() =>
{
Logger.LogEvent(Resources.Text.Nuget_InstallingPackage, LogLevel.Status);
try
{
foreach (string packageId in packageIds)
{
IVsPackageInstaller2 installer = _componentModel.GetService <IVsPackageInstaller2>();
installer.InstallLatestPackage(null, project, packageId, true, false);
}
Telemetry.TrackUserTask("Install-NugetPackage");
Logger.LogEvent(Resources.Text.Nuget_PackageInstalled, LogLevel.Status);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToInstall, LogLevel.Status);
}
});
}
else
{
await Task.Run(() =>
{
Logger.LogEvent(Resources.Text.Nuget_UninstallingPackage, LogLevel.Status);
try
{
foreach (string packageId in packageIds)
{
IVsPackageUninstaller uninstaller = _componentModel.GetService <IVsPackageUninstaller>();
uninstaller.UninstallPackage(project, packageId, false);
}
Telemetry.TrackUserTask("Uninstall-NugetPackage");
Logger.LogEvent(Resources.Text.Nuget_PackageUninstalled, LogLevel.Status);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToUninstall, LogLevel.Status);
}
});
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToInstall, LogLevel.Status);
}
}
private async Task ExecuteAsync(object sender, EventArgs e)
{
Telemetry.TrackUserTask("Execute-InstallLibraryCommand");
ProjectItem item = await VsHelpers.GetSelectedItemAsync().ConfigureAwait(false);
Project project = await VsHelpers.GetProjectOfSelectedItemAsync().ConfigureAwait(false);
if (project != null)
{
string rootFolder = await project.GetRootFolderAsync().ConfigureAwait(false);
string configFilePath = Path.Combine(rootFolder, Constants.ConfigFileName);
IDependencies dependencies = Dependencies.FromConfigFile(configFilePath);
Manifest manifest = await GetManifestAsync(configFilePath, dependencies).ConfigureAwait(false);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
// If the manifest contains errors, we will not invoke the "Add Client-Side libraries" dialog
// Instead we will display a message box indicating the syntax errors in manifest file.
if (manifest == null)
{
IVsUIShell shell = Package.GetGlobalService(typeof(SVsUIShell)) as IVsUIShell;
int result;
shell.ShowMessageBox(dwCompRole: 0,
rclsidComp: Guid.Empty,
pszTitle: null,
pszText: PredefinedErrors.ManifestMalformed().Message,
pszHelpFile: null,
dwHelpContextID: 0,
msgbtn: OLEMSGBUTTON.OLEMSGBUTTON_OK,
msgdefbtn: OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
msgicon: OLEMSGICON.OLEMSGICON_WARNING,
fSysAlert: 0,
pnResult: out result);
return;
}
string target = string.Empty;
// Install command was invoked from a folder.
// So the initial target location should be name of the folder from which
// the command was invoked.
if (item != null)
{
target = item.FileNames[1];
}
else
{
// Install command was invoked from project scope.
// If wwwroot exists, initial target location should be - wwwroot/lib.
// Else, target location should be - lib
if (Directory.Exists(Path.Combine(rootFolder, "wwwroot")))
{
target = Path.Combine(rootFolder, "wwwroot", "lib") + Path.DirectorySeparatorChar;
}
else
{
target = Path.Combine(rootFolder, "lib") + Path.DirectorySeparatorChar;
}
}
UI.InstallDialog dialog = new UI.InstallDialog(dependencies, _libraryCommandService, configFilePath, target, rootFolder, project);
var dte = (DTE)Package.GetGlobalService(typeof(SDTE));
int hwnd = dte.MainWindow.HWnd;
WindowInteropHelper windowInteropHelper = new WindowInteropHelper(dialog);
// Set visual studio window's handle as the owner of the dialog.
// This will remove the dialog from alt-tab list and will not allow the user to switch the dialog box to the background
windowInteropHelper.Owner = new IntPtr(hwnd);
dialog.ShowDialog();
Telemetry.TrackUserTask("Open-InstallDialog");
}
}
private async Task ExecuteAsync(object sender, EventArgs e)
{
Telemetry.TrackUserTask("Execute-InstallLibraryCommand");
ProjectItem item = await VsHelpers.GetSelectedItemAsync().ConfigureAwait(false);
Project project = await VsHelpers.GetProjectOfSelectedItemAsync().ConfigureAwait(false);
if (project != null)
{
string rootFolder = await project.GetRootFolderAsync().ConfigureAwait(false);
string configFilePath = Path.Combine(rootFolder, Constants.ConfigFileName);
IDependencies dependencies = _dependenciesFactory.FromConfigFile(configFilePath);
Manifest manifest = await GetManifestAsync(configFilePath, dependencies).ConfigureAwait(false);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
// If the manifest contains errors, we will not invoke the "Add Client-Side libraries" dialog
// Instead we will display a message box indicating the syntax errors in manifest file.
if (manifest == null)
{
IVsUIShell shell = Package.GetGlobalService(typeof(SVsUIShell)) as IVsUIShell;
int result;
shell.ShowMessageBox(dwCompRole: 0,
rclsidComp: Guid.Empty,
pszTitle: null,
pszText: PredefinedErrors.ManifestMalformed().Message,
pszHelpFile: null,
dwHelpContextID: 0,
msgbtn: OLEMSGBUTTON.OLEMSGBUTTON_OK,
msgdefbtn: OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
msgicon: OLEMSGICON.OLEMSGICON_WARNING,
fSysAlert: 0,
pnResult: out result);
return;
}
string target = string.Empty;
// Install command was invoked from a folder.
// So the initial target location should be name of the folder from which
// the command was invoked.
if (item != null)
{
target = item.FileNames[1];
}
else
{
// Install command was invoked from project scope.
// If wwwroot exists, initial target location should be - wwwroot/lib.
// Else, target location should be - lib
if (Directory.Exists(Path.Combine(rootFolder, "wwwroot")))
{
target = Path.Combine(rootFolder, "wwwroot", "lib") + Path.DirectorySeparatorChar;
}
else
{
target = Path.Combine(rootFolder, "lib") + Path.DirectorySeparatorChar;
}
}
string initialTargetLocation = CalculateSuggestedInstallPath(target, rootFolder);
var selectedProviderBinding = new SelectedProviderBinding();
var libraryIdViewModel = new LibraryIdViewModel(new ProviderCatalogSearchService(() => selectedProviderBinding.SelectedProvider),
string.Empty);
var libraryNameBinding = new LibraryNameBinding();
var targetLocationViewModel = new TargetLocationViewModel(initialTargetLocation,
libraryNameBinding,
new LocationSearchService(dependencies.GetHostInteractions()));
var dialogViewModel = new InstallDialogViewModel(
_libraryCommandService,
configFilePath,
dependencies,
libraryIdViewModel,
targetLocationViewModel,
selectedProviderBinding,
libraryNameBinding,
target,
project);
var dialog = new UI.InstallDialog(dialogViewModel);
dialog.ShowModal();
Telemetry.TrackUserTask("Open-InstallDialog");
}
}
private void Execute(object sender, EventArgs e)
{
ProjectItem item = VsHelpers.DTE.SelectedItems.Item(1).ProjectItem;
try
{
var dependencies = Dependencies.FromConfigFile(item.FileNames[1]);
IEnumerable <string> packageIds = dependencies.Providers.Select(p => p.NuGetPackageId).Distinct();
if (!_isPackageInstalled)
{
if (!UserWantsToInstall())
{
return;
}
System.Threading.Tasks.Task.Run(() =>
{
Logger.LogEvent(Resources.Text.Nuget_InstallingPackage, LogLevel.Status);
try
{
foreach (string packageId in packageIds)
{
IVsPackageInstaller2 installer = _componentModel.GetService <IVsPackageInstaller2>();
installer.InstallLatestPackage(null, item.ContainingProject, packageId, true, false);
}
Telemetry.TrackUserTask("InstallNugetPackage");
Logger.LogEvent(Resources.Text.Nuget_PackageInstalled, LogLevel.Status);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToInstall, LogLevel.Status);
}
});
}
else
{
System.Threading.Tasks.Task.Run(() =>
{
Logger.LogEvent(Resources.Text.Nuget_UninstallingPackage, LogLevel.Status);
try
{
foreach (string packageId in packageIds)
{
IVsPackageUninstaller uninstaller = _componentModel.GetService <IVsPackageUninstaller>();
uninstaller.UninstallPackage(item.ContainingProject, packageId, false);
}
Telemetry.TrackUserTask("UninstallNugetPackage");
Logger.LogEvent(Resources.Text.Nuget_PackageUninstalled, LogLevel.Status);
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToUninstall, LogLevel.Status);
}
});
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(RestoreOnBuildCommand), ex);
Logger.LogEvent(Resources.Text.Nuget_PackageFailedToInstall, LogLevel.Status);
}
}
