public PackageInitializationScripts(
ISolutionPackageRepository solutionPackageRepository,
IPackageScriptFactory scriptFactory)
{
this.solutionPackageRepository = solutionPackageRepository;
this.scriptFactory = scriptFactory;
}
public PackageInitializationScripts(
ISolutionPackageRepository solutionPackageRepository,
IPackageScriptFactory scriptFactory)
{
this.solutionPackageRepository = solutionPackageRepository;
this.scriptFactory = scriptFactory;
}
public IQueryable<IPackage> GetPackages()
{
ISolutionPackageRepository repository = CreateSolutionPackageRepository();
List<IPackageManagementProject> projects = GetProjects(ActivePackageRepository).ToList();
return repository
.GetPackages()
.Where(package => IsPackageInstalledInSolutionOrAnyProject(projects, package));
}
public IPackageManager CreatePackageManager(
IPackageRepository sourceRepository,
ISolutionPackageRepository solutionPackageRepository)
{
return(new PackageManager(
sourceRepository,
solutionPackageRepository.PackagePathResolver,
solutionPackageRepository.FileSystem,
solutionPackageRepository.Repository));
}
public IPackageManager CreatePackageManager (
IPackageRepository sourceRepository,
ISolutionPackageRepository solutionPackageRepository)
{
return new PackageManager (
sourceRepository,
solutionPackageRepository.PackagePathResolver,
solutionPackageRepository.FileSystem,
solutionPackageRepository.Repository);
}
public void GetRepository_OpenSolution_ReturnsRepositoryForSolution()
{
CreateSolution();
var fakeSolution = new FakeSolution(@"d:\projects\MyProject\MySolution.sln");
fakeProjectService.OpenSolution = fakeSolution;
ISolutionPackageRepository repository = solution.GetRepository();
Assert.IsNotNull(repository);
Assert.AreEqual(fakeSolutionPackageRepositoryFactory.SolutionPassedToCreateSolutionPackageRepository, fakeSolution);
Assert.AreEqual(fakeSolutionPackageRepositoryFactory.FakeSolutionPackageRepository, repository);
}
public SharpDevelopPackageManager(
IPackageRepository sourceRepository,
IProjectSystem projectSystem,
ISolutionPackageRepository solutionPackageRepository,
IPackageOperationResolverFactory packageOperationResolverFactory)
: base(sourceRepository,
solutionPackageRepository.PackagePathResolver,
solutionPackageRepository.FileSystem,
solutionPackageRepository.Repository)
{
this.projectSystem = projectSystem;
this.packageOperationResolverFactory = packageOperationResolverFactory;
CreateProjectManager();
}
void GetInstallOperationsForSolutionPackage(
ISolutionPackageRepository solutionRepository,
InstallPackageAction installAction,
IPackageFromRepository installPackage)
{
var resolverFactory = new PackageOperationsResolverFactory();
var resolver = resolverFactory.CreateInstallPackageOperationResolver(
solutionRepository.Repository,
installPackage.Repository,
logger,
installAction);
packageOperations = resolver.ResolveOperations(installPackage);
}
void GetUpdateOperationsForSolutionPackage(
ISolutionPackageRepository solutionRepository,
UpdatePackageAction updateAction,
IPackageFromRepository updatePackage)
{
var resolverFactory = new PackageOperationsResolverFactory();
var resolver = resolverFactory.CreateUpdatePackageOperationResolver(
solutionRepository.Repository,
updatePackage.Repository,
logger,
updateAction);
packageOperations = resolver.ResolveOperations(updatePackage);
}
public AvailablePackagesViewModel(
IPackageManagementSolution solution,
IRegisteredPackageRepositories registeredPackageRepositories,
IRecentPackageRepository recentPackageRepository,
IPackageViewModelFactory packageViewModelFactory,
ITaskFactory taskFactory)
: base(registeredPackageRepositories, packageViewModelFactory, taskFactory)
{
this.solutionPackageRepository = solution.GetRepository();
this.recentPackageRepository = recentPackageRepository;
IsSearchable = true;
ShowPackageSources = true;
ShowPrerelease = true;
}
public AvailablePackagesViewModel (
IPackageManagementSolution solution,
IRegisteredPackageRepositories registeredPackageRepositories,
IRecentPackageRepository recentPackageRepository,
IPackageViewModelFactory packageViewModelFactory,
ITaskFactory taskFactory)
: base(registeredPackageRepositories, packageViewModelFactory, taskFactory)
{
this.solutionPackageRepository = solution.GetRepository ();
this.recentPackageRepository = recentPackageRepository;
IsSearchable = true;
ShowPackageSources = true;
ShowPrerelease = true;
}
public SharpDevelopPackageManager(
IPackageRepository sourceRepository,
IProjectSystem projectSystem,
ISolutionPackageRepository solutionPackageRepository,
IPackageOperationResolverFactory packageOperationResolverFactory)
: base(
sourceRepository,
solutionPackageRepository.PackagePathResolver,
solutionPackageRepository.FileSystem,
solutionPackageRepository.Repository)
{
this.projectSystem = projectSystem;
this.packageOperationResolverFactory = packageOperationResolverFactory;
CreateProjectManager();
}
void UpdateSolutionLevelPackage(
ISolutionPackageRepository solutionRepository,
UpdatePackageAction updateAction,
IPackageFromRepository updatePackage)
{
var packageManager = new PackageManager(
updatePackage.Repository,
solutionRepository.PackagePathResolver,
solutionRepository.FileSystem,
solutionRepository.Repository);
packageManager.UpdatePackage(
updatePackage.Id,
updateAction.UpdateDependencies,
updateAction.AllowPrereleaseVersions);
}
protected virtual void InstallPackageIntoSolution()
{
ISolutionPackageRepository solutionRepository = selectedProjects.Solution.CreateSolutionPackageRepository();
var installAction = new InstallPackageAction(null, packageManagementEvents);
installAction.Package = package;
installAction.IgnoreDependencies = false;
installAction.AllowPrereleaseVersions = parent.IncludePrerelease;
GetInstallOperationsForSolutionPackage(solutionRepository, installAction, package);
if (LicensesAccepted())
{
InstallPackageIntoSolution(solutionRepository, installAction, package);
packageManagementEvents.OnParentPackageInstalled(package);
}
}
void InstallPackageIntoSolution(
ISolutionPackageRepository solutionRepository,
InstallPackageAction installAction,
IPackageFromRepository installPackage)
{
var packageManager = new PackageManager(
installPackage.Repository,
solutionRepository.PackagePathResolver,
solutionRepository.FileSystem,
solutionRepository.Repository);
packageManager.InstallPackage(
installPackage.Id,
installPackage.Version,
installAction.IgnoreDependencies,
installAction.AllowPrereleaseVersions);
}
protected void UpdatePackageInSolution()
{
ISolutionPackageRepository solutionRepository = selectedProjects.Solution.CreateSolutionPackageRepository();
var updateAction = new UpdatePackageAction(null, packageManagementEvents);
updateAction.Package = package;
updateAction.AllowPrereleaseVersions = parent.IncludePrerelease;
GetUpdateOperationsForSolutionPackage(solutionRepository, updateAction, package);
if (LicensesAccepted())
{
UpdateSolutionLevelPackage(solutionRepository, updateAction, package);
IEnumerable <IPackage> updatedPackages = packageOperations
.Where(packageOperation => packageOperation.Package != null)
.Select(packageOperation => packageOperation.Package)
.Distinct();
packageManagementEvents.OnParentPackagesUpdated(updatedPackages);
}
}
public PackageCompatibilityChecker(ISolutionPackageRepository packageRepository)
{
this.packageRepository = packageRepository;
}
public IQueryable <IPackage> GetPackages()
{
ISolutionPackageRepository repository = CreateSolutionPackageRepository();
return(repository.GetPackages());
}
public PackageCompatibilityChecker (ISolutionPackageRepository packageRepository)
{
this.packageRepository = packageRepository;
}
public IEnumerable <IPackage> GetPackagesInReverseDependencyOrder()
{
ISolutionPackageRepository repository = CreateSolutionPackageRepository();
return(repository.GetPackagesByReverseDependencyOrder());
}
public string GetInstallPath(IPackage package)
{
ISolutionPackageRepository repository = CreateSolutionPackageRepository();
return(repository.GetInstallPath(package));
}
public bool IsPackageInstalled(IPackage package)
{
ISolutionPackageRepository repository = CreateSolutionPackageRepository();
return(repository.IsInstalled(package));
}
public IPackageManager CreatePackageManager(IPackageRepository sourceRepository, ISolutionPackageRepository solutionPackageRepository)
{
PackageRepositoryPassedToCreatePackageManager = sourceRepository;
SolutionPackageRepositoryPassedToCreatePackageManager = solutionPackageRepository;
return(FakePackageManager);
}
public IPackageManager CreatePackageManager (IPackageRepository sourceRepository, ISolutionPackageRepository solutionPackageRepository)
{
PackageRepositoryPassedToCreatePackageManager = sourceRepository;
SolutionPackageRepositoryPassedToCreatePackageManager = solutionPackageRepository;
return FakePackageManager;
}
