public NuGetUI(
     INuGetUIContext context,
     NuGetUIProjectContext projectContext)
 {
     _context          = context;
     _uiProjectContext = projectContext;
 }
 public NuGetUI(
     INuGetUIContext context,             
     NuGetUIProjectContext projectContext)
 {
     _context = context;
     _uiProjectContext = projectContext;
 }
        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 NuGetUIFactory(
     ICommonOperations commonOperations,
     INuGetUILogger logger,
     ISourceControlManagerProvider sourceControlManagerProvider)
 {
     ProjectContext = new NuGetUIProjectContext(
         commonOperations,
         logger,
         sourceControlManagerProvider);
 }
        public NuGetUI(
            INuGetUIContext context,
            NuGetUIProjectContext projectContext)
        {
            _context       = context;
            ProgressWindow = projectContext;

            // set default values of properties
            FileConflictAction   = FileConflictAction.PromptUser;
            DependencyBehavior   = DependencyBehavior.Lowest;
            RemoveDependencies   = false;
            ForceRemove          = false;
            Projects             = Enumerable.Empty <NuGetProject>();
            DisplayPreviewWindow = true;
        }
        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;
        }
Example #8
0
        /// <summary>
        /// Execute the installs/uninstalls
        /// </summary>
        /// <param name="actions"></param>
        /// <param name="projectContext"></param>
        /// <param name="token"></param>
        /// <returns></returns>
        protected async Task ExecuteActions(IEnumerable <Tuple <NuGetProject, NuGetProjectAction> > actions,
                                            NuGetUIProjectContext projectContext, UserAction userAction, CancellationToken token)
        {
            HashSet <PackageIdentity> processedDirectInstalls = new HashSet <PackageIdentity>(PackageIdentity.Comparer);

            foreach (var projectActions in actions.GroupBy(e => e.Item1))
            {
                var nuGetProjectActions = projectActions.Select(e => e.Item2);
                var directInstall       = GetDirectInstall(nuGetProjectActions, userAction, projectContext.CommonOperations);
                if (directInstall != null && !processedDirectInstalls.Contains(directInstall))
                {
                    NuGetPackageManager.SetDirectInstall(directInstall, projectContext);
                    processedDirectInstalls.Add(directInstall);
                }
                await _packageManager.ExecuteNuGetProjectActionsAsync(projectActions.Key, nuGetProjectActions, projectContext, token);

                NuGetPackageManager.ClearDirectInstall(projectContext);
            }
        }
 /// <summary>
 /// Returns the UI for the project or given set of projects.
 /// </summary>
 public INuGetUI Create(
     INuGetUIContext uiContext, 
     NuGetUIProjectContext uiProjectContext)
 {
     return new NuGetUI(uiContext, uiProjectContext);
 }
 /// <summary>
 /// Returns the UI for the project or given set of projects.
 /// </summary>
 public INuGetUI Create(
     INuGetUIContext uiContext,
     NuGetUIProjectContext uiProjectContext)
 {
     return(new NuGetUI(uiContext, uiProjectContext));
 }
 /// <summary>
 /// Execute the installs/uninstalls
 /// </summary>
 /// <param name="actions"></param>
 /// <param name="projectContext"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 protected async Task ExecuteActions(IEnumerable<Tuple<NuGetProject, NuGetProjectAction>> actions,
     NuGetUIProjectContext projectContext, UserAction userAction, CancellationToken token)
 {
     HashSet<PackageIdentity> processedDirectInstalls = new HashSet<PackageIdentity>(PackageIdentity.Comparer);
     foreach (var projectActions in actions.GroupBy(e => e.Item1))
     {
         var nuGetProjectActions = projectActions.Select(e => e.Item2);
         var directInstall = GetDirectInstall(nuGetProjectActions, userAction, projectContext.CommonOperations);
         if (directInstall != null && !processedDirectInstalls.Contains(directInstall))
         {
             NuGetPackageManager.SetDirectInstall(directInstall, projectContext);
             processedDirectInstalls.Add(directInstall);
         }
         await _packageManager.ExecuteNuGetProjectActionsAsync(projectActions.Key, nuGetProjectActions, projectContext, token);
         NuGetPackageManager.ClearDirectInstall(projectContext);
     }
 }