// Load items using the specified loader
internal void LoadItems(
IPackageItemLoader loader,
string loadingMessage,
INuGetUILogger logger,
Task <SearchResult <IPackageSearchMetadata> > searchResultTask,
CancellationToken token)
{
_loader = loader;
_logger = logger;
_initialSearchResultTask = searchResultTask;
_loadingStatusIndicator.Reset(loadingMessage);
_loadingStatusBar.Visibility = Visibility.Hidden;
_loadingStatusBar.Reset(loadingMessage, loader.IsMultiSource);
var selectedPackageItem = SelectedPackageItem;
_itemsLock.Wait();
try
{
ClearPackageList();
}
finally
{
_itemsLock.Release();
}
_selectedCount = 0;
// triggers the package list loader
LoadItems(selectedPackageItem, token);
}
// Load items using the specified loader
internal void LoadItems(IItemLoader <PackageItemListViewModel> loader, string loadingMessage, INuGetUILogger logger)
{
_loader = loader;
_logger = logger;
_loadingStatusIndicator.Reset(loadingMessage);
_loadingStatusBar.Visibility = Visibility.Hidden;
_loadingStatusBar.Reset(loadingMessage, loader.IsMultiSource);
var selectedPackageItem = SelectedPackageItem;
_itemsLock.Wait();
try
{
ClearPackageList();
}
finally
{
_itemsLock.Release();
}
_selectedCount = 0;
// triggers the package list loader
LoadItems(selectedPackageItem);
}
public static async Task <NuGetUI> CreateAsync(
IServiceBroker serviceBroker,
ICommonOperations commonOperations,
NuGetUIProjectContext projectContext,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
SolutionUserOptions solutionUserOptions,
INuGetLockService lockService,
INuGetUILogger logger,
IRestoreProgressReporter restoreProgressReporter,
CancellationToken cancellationToken,
params IProjectContextInfo[] projects)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(commonOperations);
Assumes.NotNull(projectContext);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(solutionUserOptions);
Assumes.NotNull(lockService);
Assumes.NotNull(restoreProgressReporter);
Assumes.NotNull(logger);
cancellationToken.ThrowIfCancellationRequested();
var nuGetUi = new NuGetUI(
commonOperations,
projectContext,
logger)
{
UIContext = await NuGetUIContext.CreateAsync(
serviceBroker,
sourceRepositoryProvider,
settings,
solutionManager,
packageRestoreManager,
optionsPageActivator,
solutionUserOptions,
deleteOnRestartManager,
lockService,
restoreProgressReporter,
cancellationToken)
};
nuGetUi.UIContext.Projects = projects;
return(nuGetUi);
}
// For testing purposes only.
internal NuGetUI(
ICommonOperations commonOperations,
NuGetUIProjectContext projectContext,
INuGetUILogger logger,
NuGetUIContext uiContext)
: this(commonOperations, projectContext, logger)
{
UIContext = uiContext;
}
public GeneralOptionControl()
{
InitializeComponent();
_settings = ServiceLocator.GetInstance <Configuration.ISettings>();
_outputConsoleLogger = ServiceLocator.GetInstance <INuGetUILogger>();
_localsCommandRunner = new LocalsCommandRunner();
AutoScroll = true;
Debug.Assert(_settings != null);
}
public NuGetUIFactory(
ICommonOperations commonOperations,
INuGetUILogger logger,
ISourceControlManagerProvider sourceControlManagerProvider)
{
ProjectContext = new NuGetUIProjectContext(
commonOperations,
logger,
sourceControlManagerProvider);
}
public NuGetUIProjectContext(INuGetUILogger logger, ISourceControlManagerProvider sourceControlManagerProvider, ICommonOperations commonOperations)
{
_logger = logger;
_uiDispatcher = Dispatcher.CurrentDispatcher;
SourceControlManagerProvider = sourceControlManagerProvider;
CommonOperations = commonOperations;
if (commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(commonOperations);
}
}
public GeneralOptionControl()
{
InitializeComponent();
var componentModel = NuGetUIThreadHelper.JoinableTaskFactory.Run(ServiceLocator.GetComponentModelAsync);
_settings = componentModel.GetService <ISettings>();
_outputConsoleLogger = componentModel.GetService <INuGetUILogger>();
_localsCommandRunner = new LocalsCommandRunner();
AutoScroll = true;
Debug.Assert(_settings != null);
}
public NuGetUIProjectContext(INuGetUILogger logger, ISourceControlManagerProvider sourceControlManagerProvider, ICommonOperations commonOperations)
{
_logger = logger;
_uiDispatcher = Dispatcher.CurrentDispatcher;
_sourceControlManagerProvider = sourceControlManagerProvider;
_commonOperations = commonOperations;
if (commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(commonOperations);
}
}
private NuGetUI CreateNuGetUI(INuGetUILogger defaultLogger, INuGetUILogger projectLogger)
{
var uiContext = CreateNuGetUIContext();
return(new NuGetUI(
Mock.Of <ICommonOperations>(),
new NuGetUIProjectContext(
Mock.Of <ICommonOperations>(),
projectLogger,
Mock.Of <ISourceControlManagerProvider>()),
defaultLogger,
uiContext));
}
public GeneralOptionControl(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
InitializeComponent();
_settings = ServiceLocator.GetInstance <Configuration.ISettings>();
_serviceprovider = serviceProvider;
_outputConsoleLogger = ServiceLocator.GetInstance <INuGetUILogger>();
_localsCommandRunner = new LocalsCommandRunner();
Debug.Assert(_settings != null);
}
// Load items using the specified loader
internal void LoadItems(
IPackageItemLoader loader,
string loadingMessage,
INuGetUILogger logger,
Task <SearchResult <IPackageSearchMetadata> > searchResultTask,
CancellationToken token)
{
if (loader == null)
{
throw new ArgumentNullException(nameof(loader));
}
if (string.IsNullOrEmpty(loadingMessage))
{
throw new ArgumentException(Strings.Argument_Cannot_Be_Null_Or_Empty, nameof(loadingMessage));
}
if (searchResultTask == null)
{
throw new ArgumentNullException(nameof(searchResultTask));
}
token.ThrowIfCancellationRequested();
_loader = loader;
_logger = logger;
_initialSearchResultTask = searchResultTask;
_loadingStatusIndicator.Reset(loadingMessage);
_loadingStatusBar.Visibility = Visibility.Hidden;
_loadingStatusBar.Reset(loadingMessage, loader.IsMultiSource);
var selectedPackageItem = SelectedPackageItem;
_itemsLock.Wait();
try
{
ClearPackageList();
}
finally
{
_itemsLock.Release();
}
_selectedCount = 0;
// triggers the package list loader
LoadItems(selectedPackageItem, token);
}
public MultiSourcePackageFeed(IEnumerable<SourceRepository> sourceRepositories, INuGetUILogger logger)
{
if (sourceRepositories == null)
{
throw new ArgumentNullException(nameof(sourceRepositories));
}
if (!sourceRepositories.Any())
{
throw new ArgumentException("Collection of source repositories cannot be empty", nameof(sourceRepositories));
}
_sourceRepositories = sourceRepositories.ToArray();
_logger = logger;
}
public MultiSourcePackageFeed(IEnumerable <SourceRepository> sourceRepositories, INuGetUILogger logger)
{
if (sourceRepositories == null)
{
throw new ArgumentNullException(nameof(sourceRepositories));
}
if (!sourceRepositories.Any())
{
throw new ArgumentException("Collection of source repositories cannot be empty", nameof(sourceRepositories));
}
_sourceRepositories = sourceRepositories.ToArray();
_logger = logger;
}
public NuGetUIFactory(
ICommonOperations commonOperations,
INuGetUILogger logger,
ISourceControlManagerProvider sourceControlManagerProvider)
{
ProjectContext = new NuGetUIProjectContext(
commonOperations,
logger,
sourceControlManagerProvider);
var adapterLogger = new LoggerAdapter(ProjectContext);
ProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings.Value, adapterLogger),
adapterLogger);
}
private NuGetUI(
ICommonOperations commonOperations,
NuGetUIProjectContext projectContext,
INuGetUILogger logger)
{
CommonOperations = commonOperations;
_projectContext = projectContext;
UILogger = logger;
// set default values of properties
FileConflictAction = FileConflictAction.PromptUser;
DependencyBehavior = DependencyBehavior.Lowest;
RemoveDependencies = false;
ForceRemove = false;
Projects = Enumerable.Empty <IProjectContextInfo>();
DisplayPreviewWindow = true;
DisplayDeprecatedFrameworkWindow = true;
}
// Load items using the specified loader
internal async Task LoadItemsAsync(
IPackageItemLoader loader,
string loadingMessage,
INuGetUILogger logger,
Task <SearchResultContextInfo> searchResultTask,
CancellationToken token)
{
if (loader == null)
{
throw new ArgumentNullException(nameof(loader));
}
if (string.IsNullOrEmpty(loadingMessage))
{
throw new ArgumentException(Strings.Argument_Cannot_Be_Null_Or_Empty, nameof(loadingMessage));
}
if (searchResultTask == null)
{
throw new ArgumentNullException(nameof(searchResultTask));
}
token.ThrowIfCancellationRequested();
_loader = loader;
_logger = logger;
_initialSearchResultTask = searchResultTask;
_loadingStatusIndicator.Reset(loadingMessage);
_loadingStatusBar.Visibility = Visibility.Hidden;
_loadingStatusBar.Reset(loadingMessage, loader.IsMultiSource);
var selectedPackageItem = SelectedPackageItem;
await _list.ItemsLock.ExecuteAsync(() =>
{
ClearPackageList();
return(Task.CompletedTask);
});
_selectedCount = 0;
// triggers the package list loader
await LoadItemsAsync(selectedPackageItem, token);
}
public NuGetUIFactory(
ICommonOperations commonOperations,
INuGetUILogger logger,
ISourceControlManagerProvider sourceControlManagerProvider)
{
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
ProjectContext = new NuGetUIProjectContext(
commonOperations,
logger,
sourceControlManagerProvider);
ProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(ProjectContext),
signedPackageVerifier,
SignedPackageVerifierSettings.GetDefault());
}
public NuGetUIProjectContext(
ICommonOperations commonOperations,
INuGetUILogger logger,
ISourceControlManagerProvider sourceControlManagerProvider)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (sourceControlManagerProvider == null)
{
throw new ArgumentNullException(nameof(sourceControlManagerProvider));
}
_logger = logger;
SourceControlManagerProvider = sourceControlManagerProvider;
if (commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(commonOperations);
}
}
public PackageManagerControl(
PackageManagerModel model,
Configuration.ISettings nugetSettings,
IVsWindowSearchHostFactory searchFactory,
IVsShell4 vsShell,
INuGetUILogger uiLogger = null)
{
_uiDispatcher = Dispatcher.CurrentDispatcher;
_uiLogger = uiLogger;
Model = model;
Settings = nugetSettings;
if (!Model.IsSolution)
{
_detailModel = new PackageDetailControlModel(Model.Context.SolutionManager, Model.Context.Projects);
}
else
{
_detailModel = new PackageSolutionDetailControlModel(
Model.Context.SolutionManager,
Model.Context.Projects,
Model.Context.PackageManagerProviders);
}
InitializeComponent();
_windowSearchHostFactory = searchFactory;
if (_windowSearchHostFactory != null)
{
_windowSearchHost = _windowSearchHostFactory.CreateWindowSearchHost(
_topPanel.SearchControlParent);
_windowSearchHost.SetupSearch(this);
_windowSearchHost.IsVisible = true;
}
AddRestoreBar();
AddRestartRequestBar(vsShell);
AddPackagesErrorBar();
_packageDetail.Control = this;
_packageDetail.Visibility = Visibility.Hidden;
SetTitle();
_topPanel.IsSolution = Model.IsSolution;
var settings = LoadSettings();
InitializeFilterList(settings);
InitSourceRepoList(settings);
ApplySettings(settings, nugetSettings);
_initialized = true;
// UI is initialized. Start the first search
_packageList.CheckBoxesEnabled = _topPanel.Filter == ItemFilter.UpdatesAvailable;
_packageList.IsSolution = this.Model.IsSolution;
Loaded += (_, __) =>
{
SearchPackagesAndRefreshUpdateCount(_windowSearchHost.SearchQuery.SearchString, useCache: false);
RefreshConsolidatablePackagesCount();
};
// register with the UI controller
var controller = model.UIController as NuGetUI;
if (controller != null)
{
controller.PackageManagerControl = this;
}
var solutionManager = Model.Context.SolutionManager;
solutionManager.NuGetProjectAdded += SolutionManager_ProjectsChanged;
solutionManager.NuGetProjectRemoved += SolutionManager_ProjectsChanged;
solutionManager.NuGetProjectUpdated += SolutionManager_ProjectsUpdated;
solutionManager.NuGetProjectRenamed += SolutionManager_ProjectRenamed;
solutionManager.ActionsExecuted += SolutionManager_ActionsExecuted;
solutionManager.AfterNuGetCacheUpdated += SolutionManager_CacheUpdated;
Model.Context.SourceProvider.PackageSourceProvider.PackageSourcesChanged += Sources_PackageSourcesChanged;
if (IsUILegalDisclaimerSuppressed())
{
_legalDisclaimer.Visibility = Visibility.Collapsed;
}
_missingPackageStatus = false;
}
private static async Task <IPackageFeed> CreatePackageFeedAsync(PackageLoadContext context, ItemFilter filter, INuGetUILogger uiLogger)
{
var logger = new VisualStudioActivityLogger();
if (filter == ItemFilter.All)
{
return(new MultiSourcePackageFeed(context.SourceRepositories, uiLogger));
}
var metadataProvider = CreatePackageMetadataProvider(context);
var installedPackages = await context.GetInstalledPackagesAsync();
if (filter == ItemFilter.Installed)
{
return(new InstalledPackageFeed(installedPackages, metadataProvider, logger));
}
if (filter == ItemFilter.Consolidate)
{
return(new ConsolidatePackageFeed(installedPackages, metadataProvider, logger));
}
// Search all / updates available cannot work without a source repo
if (context.SourceRepositories == null)
{
return(null);
}
if (filter == ItemFilter.UpdatesAvailable)
{
return(new UpdatePackageFeed(
installedPackages,
metadataProvider,
context.Projects,
context.CachedPackages,
logger));
}
throw new InvalidOperationException("Unsupported feed type");
}
