public VsSolution(DteSolution dteSolution, ISolutionManager solutionManager, IVsPackageManager packageManager)
        {
            _name = String.Format(
                CultureInfo.CurrentCulture,
                Strings.Label_Solution,
                dteSolution.GetName());
            _solution = solutionManager;
            _packageManager = packageManager;

            var repo = (SharedPackageRepository)packageManager.LocalRepository;
            _installedSolutionLevelPackages = new CoreInteropInstalledPackagesList(
                new PackageReferenceRepository(repo.PackageReferenceFile.FullPath, repo));

            DteSolution = dteSolution;

            // Add V2-related interop features
            AddFeature(() => packageManager.LocalRepository);
            AddFeature<IPackageManager>(() => packageManager);
            AddFeature<IPackageCacheRepository>(() => MachineCache.Default);

            // the source repository of the local repo of the solution
            AddFeature<SourceRepository>(() =>
            {
                var localRepo = new NuGet.Client.Interop.V2SourceRepository(
                    null,
                    packageManager.LocalRepository,
                    "");
                return localRepo;
            });

            // Add PowerShell feature
            AddFeature<PowerShellScriptExecutor>(() =>
                new VsPowerShellScriptExecutor(ServiceLocator.GetInstance<IScriptExecutor>()));
        }

        protected internal override IVsPackageManager GetActivePackageManager()
        {
            if (_recentPackageManager == null)
            {
                var repository = _packageSourceProvider.GetAggregate(_packageRepositoryFactory, ignoreFailingRepositories: true);
                _recentPackageManager = _packageManagerFactory.CreatePackageManager(repository, useFallbackForDependencies: false);
            }

            return _recentPackageManager;
        }

 public InstalledProvider(
     IVsPackageManager packageManager,
     Project project,
     IProjectManager projectManager,
     ResourceDictionary resources,
     ProviderServices providerServices,
     IProgressProvider progressProvider)
     : base(project, projectManager, resources, providerServices, progressProvider)
 {
     _packageManager = packageManager;
 }

 public SolutionInstalledProvider(
     IVsPackageManager packageManager,
     IPackageRepository localRepository,
     ResourceDictionary resources,
     ProviderServices providerServices,
     IProgressProvider progressProvider,
     ISolutionManager solutionManager,
     IPackageRestoreManager packageRestoreManager)
     : base(packageManager, null, localRepository, resources, providerServices, progressProvider, solutionManager, packageRestoreManager)
 {
     _userNotifierServices = providerServices.UserNotifierServices;
 }

 public MockPackagesProvider(IPackageRepository localRepository, IVsPackageManager packageManagerr, IEnumerable<string> supportedFrameworks)
     : base(localRepository, 
            new ResourceDictionary(), 
            new ProviderServices(
                new Mock<IUserNotifierServices>().Object,
                new Mock<IProgressWindowOpener>().Object,
                new Mock<IProviderSettings>().Object,
                new Mock<IScriptExecutor>().Object,
                new MockOutputConsoleProvider(),
                new Mock<IVsCommonOperations>().Object),
            new Mock<IProgressProvider>().Object, 
            new Mock<ISolutionManager>().Object)
 {
     _supportedFrameworks = supportedFrameworks;
 }

        public InstalledProvider(
            IVsPackageManager packageManager,
            Project project,
            IPackageRepository localRepository,
            ResourceDictionary resources,
            ProviderServices providerServices,
            IProgressProvider progressProvider,
            ISolutionManager solutionManager)
            : base(localRepository, resources, providerServices, progressProvider, solutionManager)
        {

            if (packageManager == null)
            {
                throw new ArgumentNullException("packageManager");
            }

            _packageManager = packageManager;
            _project = project;
            _userNotifierServices = providerServices.UserNotifierServices;
        }

        public InstalledProvider(
            IVsPackageManager packageManager,
            Project project,
            IPackageRepository localRepository,
            ResourceDictionary resources,
            ProviderServices providerServices,
            IProgressProvider progressProvider,
            ISolutionManager solutionManager,
            IPackageRestoreManager packageRestoreManager)
            : base(localRepository, resources, providerServices, progressProvider, solutionManager)
        {
            if (packageManager == null)
            {
                throw new ArgumentNullException("packageManager");
            }

            _packageManager = packageManager;
            _project = project;
            _targetFramework = _project.GetTargetFrameworkName();
            _userNotifierServices = providerServices.UserNotifierServices;
            _packageRestoreManager = packageRestoreManager;
            _packageRestoreManager.PackagesMissingStatusChanged += OnMissPackagesChanged;
        }

        private void InstallPackage(IVsPackageManager packageManager)
        {
            if (packageManager == null)
            {
                return;
            }

            packageManager.DependencyVersion = DependencyVersion;
            packageManager.WhatIf = WhatIf;
            packageManager.InstallPackage(ProjectManager, Id, Version, IgnoreDependencies, IncludePrerelease.IsPresent, logger: this);
        }

        protected bool ShowLicenseAgreement(IVsPackageManager packageManager, IEnumerable<PackageOperation> operations)
        {
            var licensePackages = from o in operations
                                  where o.Action == PackageAction.Install &&
                                        o.Package.RequireLicenseAcceptance &&
                                        !packageManager.LocalRepository.Exists(o.Package)
                                  select o.Package;

            // display license window if necessary
            if (licensePackages.Any())
            {
                // hide the progress window if we are going to show license window
                HideProgressWindow();

                bool accepted = _providerServices.UserNotifierServices.ShowLicenseWindow(licensePackages);
                if (!accepted)
                {
                    return false;
                }

                ShowProgressWindow();
            }

            return true;
        }

 public void OnAfterPackageOperation(IVsPackageManager packageManager)
 {
 }

        protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList<PackageOperation> allOperations, out IList<IPackage> packagesByDependencyOrder)
        {
            allOperations = new List<PackageOperation>();
            var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
            if (_project.SupportsINuGetProjectSystem())
            {
                packagesByDependencyOrder = allPackages.ToList();
                foreach (var package in allPackages)
                {
                    allOperations.Add(new PackageOperation(package, PackageAction.Install));
                }
            }
            else
            {
                var installWalker = new InstallWalker(
                    LocalRepository,
                    activePackageManager.SourceRepository,
                    _project.GetTargetFrameworkName(),
                    logger: this,
                    ignoreDependencies: false,
                    allowPrereleaseVersions: IncludePrerelease,
                    dependencyVersion: activePackageManager.DependencyVersion);
                allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
            }

            return ShowLicenseAgreement(activePackageManager, allOperations);
        }

 protected void ExecuteCommandOnProject(Project activeProject, PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
 {
     IProjectManager projectManager = null;
     try
     {
         projectManager = activePackageManager.GetProjectManager(activeProject);
         RegisterPackageOperationEvents(activePackageManager, projectManager);
         ExecuteCommand(projectManager, item, activePackageManager, operations);
     }
     finally
     {
         if (projectManager != null)
         {
             UnregisterPackageOperationEvents(activePackageManager, projectManager);
         }
     }
 }

        private static InstalledProvider CreateInstalledProvider(
            IVsPackageManager packageManager = null,
            IPackageRepository localRepository = null,
            Project project = null,
            IScriptExecutor scriptExecutor = null,
            ISolutionManager solutionManager = null,
            IPackageRestoreManager packageRestoreManager = null)
        {
            if (packageManager == null)
            {
                packageManager = new Mock<IVsPackageManager>().Object;
            }

            var mockProgressWindowOpener = new Mock<IProgressWindowOpener>();

            if (project == null)
            {
                project = new Mock<Project>().Object;
            }

            if (scriptExecutor == null)
            {
                scriptExecutor = new Mock<IScriptExecutor>().Object;
            }

            var services = new ProviderServices(
                null,
                mockProgressWindowOpener.Object,
                new Mock<IProviderSettings>().Object,
                new Mock<IUpdateAllUIService>().Object,
                scriptExecutor,
                new MockOutputConsoleProvider(),
                new Mock<IVsCommonOperations>().Object
            );

            if (localRepository == null)
            {
                localRepository = new MockPackageRepository();
            }

            if (solutionManager == null)
            {
                solutionManager = new Mock<ISolutionManager>().Object;
            }

            if (packageRestoreManager == null)
            {
                packageRestoreManager = new Mock<IPackageRestoreManager>().Object;
            }

            return new InstalledProvider(
                packageManager,
                project,
                localRepository,
                new System.Windows.ResourceDictionary(),
                services,
                new Mock<IProgressProvider>().Object,
                solutionManager,
                packageRestoreManager);
        }

 protected bool ShowLicenseAgreement(
     IPackage package,
     IVsPackageManager packageManager,
     FrameworkName targetFramework,
     out IList<PackageOperation> operations)   
 {
     var walker = new InstallWalker(
         LocalRepository,
         packageManager.SourceRepository,
         targetFramework,
         this,
         ignoreDependencies: false,
         allowPrereleaseVersions: IncludePrerelease,
         dependencyVersion: packageManager.DependencyVersion);
     operations = walker.ResolveOperations(package).ToList();
     return ShowLicenseAgreement(packageManager, operations);
 }

 private IEnumerable<Resolver.PackageAction> ResolveActionsForUpdateAll(IVsPackageManager activePackageManager, IProjectManager projectManager)
 {
     var resolver = new ActionResolver()
     {
         Logger = this,
         AllowPrereleaseVersions = IncludePrerelease,
         DependencyVersion = activePackageManager.DependencyVersion
     };
     var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
     foreach (var package in allPackages)
     {
         resolver.AddOperation(PackageAction.Install, package, projectManager);
     }
     var actions = resolver.ResolveActions();
     return actions;
 }

 protected virtual void ExecuteCommand(IProjectManager projectManager, PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
 {
     activePackageManager.InstallPackage(projectManager, item.PackageIdentity, operations, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, logger: this);
 }

        /// <summary>
        /// Gets all package references in all projects of the current solution plus package 
        /// references specified in the solution packages.config
        /// </summary>
        private IEnumerable<PackageReference> GetAllPackageReferences(IVsPackageManager packageManager)
        {
            IEnumerable<PackageReference> projectReferences = from project in _solutionManager.GetProjects()
                                                              from reference in GetPackageReferences(packageManager.GetProjectManager(project))
                                                              select reference;

            var localRepository = packageManager.LocalRepository as SharedPackageRepository;
            if (localRepository != null)
            {
                IEnumerable<PackageReference> solutionReferences = localRepository.PackageReferenceFile.GetPackageReferences();
                return projectReferences.Concat(solutionReferences).Distinct();
            }

            return projectReferences.Distinct();
        }

 protected virtual void ExecuteCommand(PackageItem item, IVsPackageManager activePackageManager, IList<PackageOperation> operations)
 {
     activePackageManager.InstallPackage(ProjectManager, item.PackageIdentity, operations, ignoreDependencies: false, logger: this);
 }

        private static InstalledProvider CreateInstalledProvider(
            IVsPackageManager packageManager = null,
            IProjectManager projectManager = null,
            Project project = null,
            IScriptExecutor scriptExecutor = null)
        {
            if (packageManager == null) {
                packageManager = new Mock<IVsPackageManager>().Object;
            }

            if (projectManager == null) {
                projectManager = new Mock<IProjectManager>().Object;
            }

            var mockProgressWindowOpener = new Mock<IProgressWindowOpener>();

            if (project == null) {
                project = new Mock<Project>().Object;
            }

            if (scriptExecutor == null) {
                scriptExecutor = new Mock<IScriptExecutor>().Object;
            }

            var services = new ProviderServices(
                null,
                mockProgressWindowOpener.Object,
                scriptExecutor,
                new MockOutputConsoleProvider()
            );

            return new InstalledProvider(packageManager, project, projectManager, new System.Windows.ResourceDictionary(), services, new Mock<IProgressProvider>().Object);
        }

        protected bool CheckPSScriptAndShowLicenseAgreement(
            PackageItem item, IList<Project> projects, IVsPackageManager packageManager, out IList<PackageOperation> operations)
        {
            ShowProgressWindow();

            // combine the operations of all selected project
            var allOperations = new List<PackageOperation>();
            foreach (Project project in projects)
            {
                IProjectManager projectManager = packageManager.GetProjectManager(project);

                IList<PackageOperation> projectOperations;
                CheckInstallPSScripts(
                    item.PackageIdentity,
                    projectManager.LocalRepository,
                    packageManager.SourceRepository,
                    project.GetTargetFrameworkName(),
                    IncludePrerelease,
                    out projectOperations);

                allOperations.AddRange(projectOperations);
            }

            // reduce the operations before checking for license agreements
            operations = allOperations.Reduce();

            return ShowLicenseAgreement(packageManager, operations);
        }