public int CountPackages(IRepository packageRepository, IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageRepository);
var count = _repositoryCacheService.GetNuGetRepository(packageRepository).GetPackages().Count(x => string.Equals(x.GetFullName(), packageDetails.FullName));
return count;
}
public void Execute(PackageOperationType operationType, IPackageDetails packageDetails, IRepository sourceRepository = null, bool allowedPrerelease = false)
{
Argument.IsNotNull(() => packageDetails);
using (_pleaseWaitService.WaitingScope())
{
using (_packageOperationContextService.UseOperationContext(operationType, packageDetails))
{
_packageOperationContextService.CurrentContext.Repository = sourceRepository;
switch (operationType)
{
case PackageOperationType.Uninstall:
_packageOperationService.UninstallPackage(packageDetails);
break;
case PackageOperationType.Install:
_packageOperationService.InstallPackage(packageDetails, allowedPrerelease);
break;
case PackageOperationType.Update:
_packageOperationService.UpdatePackages(packageDetails, allowedPrerelease);
break;
}
}
}
packageDetails.IsInstalled = null;
}
public async Task ExecuteInstallAsync(IPackageDetails packageDetails, IDisposable packageOperationContext, CancellationToken token)
{
using (_pleaseWaitService.WaitingScope())
{
await _packageOperationService.InstallPackageAsync(packageDetails, token : token);
}
}
public void Execute(PackageOperationType operationType, IPackageDetails packageDetails, IRepository sourceRepository = null, bool allowedPrerelease = false)
{
Argument.IsNotNull(() => packageDetails);
using (_pleaseWaitService.WaitingScope())
{
using (_packageOperationContextService.UseOperationContext(operationType, packageDetails))
{
_packageOperationContextService.CurrentContext.Repository = sourceRepository;
switch (operationType)
{
case PackageOperationType.Uninstall:
_packageOperationService.UninstallPackage(packageDetails);
break;
case PackageOperationType.Install:
_packageOperationService.InstallPackage(packageDetails, allowedPrerelease);
break;
case PackageOperationType.Update:
_packageOperationService.UpdatePackages(packageDetails, allowedPrerelease);
break;
}
}
}
packageDetails.IsInstalled = null;
}
public async Task InstallPackageAsync(IPackageDetails package, bool allowedPrerelease = false, CancellationToken token = default)
{
Argument.IsNotNull(() => package);
var installedIdentity = package.GetIdentity();
var operationPath = _defaultProject.GetInstallPath(installedIdentity);
try
{
ValidatePackage(package);
//repositories retrieved inside package manager now
//todo use PackageOperationContextService instead on repositoryContextService
//here was used a flag 'ignoreDependencies = false' and 'ignoreWalkInfo = false' in old code
_packageOperationNotificationService.NotifyOperationStarting(operationPath, PackageOperationType.Install, package);
await _nuGetPackageManager.InstallPackageForProjectAsync(_defaultProject, package.GetIdentity(), token);
}
catch (Exception ex)
{
await _logger.LogAsync(LogLevel.Error, ex.Message);
_packageOperationContextService.CurrentContext.Exceptions.Add(ex);
}
finally
{
FinishOperation(PackageOperationType.Install, operationPath, package);
}
}
private object GetPackageDownloaderInstance(IPackageDetails packageDetails)
{
var innerPackagePropertyInfo = packageDetails.GetType().GetPropertyEx("Package");
if (innerPackagePropertyInfo == null)
{
return(null);
}
var innerPackage = innerPackagePropertyInfo.GetValue(packageDetails, null);
if (innerPackage == null)
{
return(null);
}
var downloaderPropertyInfo = innerPackage.GetType().GetPropertyEx("Downloader");
if (downloaderPropertyInfo == null)
{
return(null);
}
var downloader = downloaderPropertyInfo.GetValue(innerPackage, null);
if (downloader == null)
{
return(null);
}
return(downloader);
}
public FlowDocument PackageToFlowDocument(IPackageDetails package)
{
Argument.IsNotNull(() => package);
var result = new FlowDocument();
var paragraph = new Paragraph
{
FontSize = 12
};
var autors = GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_CreatedBy"), package.Authors.ToArray());
paragraph.Inlines.AddIfNotNull(autors);
var id = GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_Id"), package.Id);
paragraph.Inlines.AddIfNotNull(id);
var version = GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_Version"), GetVersion(package));
paragraph.Inlines.AddIfNotNull(version);
var published = package.Published;
var selectedRepository = _repositoryNavigatorService.Navigator.SelectedRepository;
if (published != null && selectedRepository?.OperationType != PackageOperationType.Uninstall)
{
paragraph.Inlines.AddIfNotNull(GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_Published"), published.Value.LocalDateTime.ToString(CultureInfo.CurrentCulture.DateTimeFormat)));
}
if (published != null && selectedRepository?.OperationType == PackageOperationType.Uninstall)
{
paragraph.Inlines.AddIfNotNull(GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_Installed"), published.Value.LocalDateTime.ToString(CultureInfo.CurrentCulture.DateTimeFormat)));
}
var downloads = GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_Downloads"), package.DownloadCount.ToString());
paragraph.Inlines.AddIfNotNull(downloads);
if (!string.IsNullOrWhiteSpace(package.Dependencies))
{
var dependencies = GetDetailsRecord(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetDetailsRecord_Dependencies"), package.Dependencies);
paragraph.Inlines.AddIfNotNull(dependencies);
}
if (package.ValidationContext.GetErrorCount(ValidationTags.Api) > 0)
{
var validations = GetAlertRecords(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetAlertRecords_Errors"), package.ValidationContext.GetErrors(ValidationTags.Api).Select(s => " - " + s.Message).ToArray());
paragraph.Inlines.AddIfNotNull(validations);
paragraph.Inlines.Add(new LineBreak());
paragraph.Inlines.Add(_languageService.GetString("NuGetExplorer_PackageDetailsService_PackageToFlowDocument_Update_The_Shell_Error_Message").ToInline(Brushes.Red));
paragraph.Inlines.Add(new LineBreak());
}
result.Blocks.Add(paragraph);
return(result);
}
public SelectablePackageDetailsViewModel(IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
_packageDetails = packageDetails;
SelectPackageVersionCommand = new Command <string>(Execute);
}
public int CountPackages(IRepository packageRepository, IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageRepository);
var count = _repositoryCacheService.GetNuGetRepository(packageRepository).GetPackages().Count(x => string.Equals(x.GetFullName(), packageDetails.FullName));
return(count);
}
public async Task ExecuteUpdateAsync(IPackageDetails packageDetails, CancellationToken token)
{
using (_pleaseWaitService.WaitingScope())
using (_packageOperationContextService.UseOperationContext(PackageOperationType.Update, packageDetails))
{
await _packageOperationService.UpdatePackagesAsync(packageDetails, token : token);
}
}
internal PackageOperationEventArgs(IPackageDetails packageDetails, string installPath, PackageOperationType packageOperationType)
{
Argument.IsNotNull(() => packageDetails);
PackageDetails = packageDetails;
InstallPath = installPath;
PackageOperationType = packageOperationType;
}
public void NotifyOperationStarting(string installPath, PackageOperationType operationType, IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
//SubscribeToDownloadProgress(packageDetails);
OperationStarting.SafeInvoke(this, new PackageOperationEventArgs(packageDetails, installPath, operationType));
}
public void NotifyOperationFinished(string installPath, PackageOperationType operationType, IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
//UnsubscribeFromDownloadProgress(packageDetails);
OperationFinished.SafeInvoke(this, new PackageOperationEventArgs(packageDetails, installPath, operationType));
}
private async Task <IPackageDetails> BuildMultiVersionPackageSearchMetadataAsync(string packageId, SourceRepository sourceRepository, bool includePrerelease)
{
var versionsMetadata = await _packageMetadataProvider.GetPackageMetadataListAsync(packageId, includePrerelease, false, CancellationToken.None);
IPackageDetails details = MultiVersionPackageSearchMetadataBuilder.FromMetadatas(versionsMetadata).Build() as IPackageDetails;
return(details);
}
internal PackageOperationEventArgs(IPackageDetails packageDetails, string installPath, PackageOperationType packageOperationType)
{
Argument.IsNotNull(() => packageDetails);
PackageDetails = packageDetails;
InstallPath = installPath;
PackageOperationType = packageOperationType;
}
private IPackageDetails GetPackageDetailsFromSelectedVersion(IPackageDetails packageDetails, IRepository repository)
{
if (!string.IsNullOrWhiteSpace(packageDetails.SelectedVersion) && packageDetails.Version.ToString() != packageDetails.SelectedVersion)
{
packageDetails = _packageQueryService.GetPackage(repository, packageDetails.Id, packageDetails.SelectedVersion);
}
return(packageDetails);
}
/// <summary>
/// Sets the forms toolbar buttons visibility based on the display mode of the package.
/// </summary>
/// <param name="form">The package details form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void OnLoadPackageForm(IPackageDetails form, EventArgs args)
{
var insertMode = MySlx.MainView.IsNewEntity();
form.btnDelete.Visible = !insertMode;
form.btnSave.Visible = !insertMode;
form.btnInsertSave.Visible = insertMode;
form.ctrlstCreateModProps.Visible = !insertMode;
}
public PackageDetailsViewModel(IPackageDetails package, IPackageDetailsService packageDetailsService)
{
Argument.IsNotNull(() => package);
Argument.IsNotNull(() => packageDetailsService);
_packageDetailsService = packageDetailsService;
Package = package;
}
private bool OnPackageActionCanExecute(IPackageDetails parameter)
{
if (Navigator.SelectedRepository == null)
{
return(false);
}
return(_packageCommandService.CanExecute(Navigator.SelectedRepository.OperationType, parameter));
}
private static string GetVersion(IPackageDetails package)
{
if (!package.IsPrerelease)
{
return package.Version.ToString();
}
return string.Format("{0}-{1}", package.Version, package.SpecialVersion);
}
private static string GetVersion(IPackageDetails package)
{
if (!package.IsPrerelease)
{
return(package.Version.ToString());
}
return(string.Format("{0}-{1}", package.Version, package.SpecialVersion));
}
public PackageDetailsViewModel(IPackageDetails package, IPackageDetailsService packageDetailsService)
{
Argument.IsNotNull(() => package);
Argument.IsNotNull(() => packageDetailsService);
_packageDetailsService = packageDetailsService;
Package = package;
}
private async Task <bool> CanUpdateAsync(IPackageDetails package)
{
Argument.IsNotNull(() => package);
package.IsInstalled ??= await _packageQueryService.PackageExistsAsync(_localRepository, package);
ValidatePackage(package);
return(!package.IsInstalled.Value && package.ValidationContext.GetErrorCount(ValidationTags.Api) == 0);
}
public async Task UpdatePackagesAsync(IPackageDetails package, bool allowedPrerelease = false, CancellationToken token = default)
{
Argument.IsNotNull(() => package);
var updateIdentity = package.GetIdentity();
var installPath = _defaultProject.GetInstallPath(updateIdentity);
// create current version identity
var currentVersion = await _nuGetPackageManager.GetVersionInstalledAsync(_defaultProject, updateIdentity.Id, token);
var currentIdentity = new PackageIdentity(updateIdentity.Id, currentVersion);
if (currentIdentity.Version is null)
{
// Can be because of mismatch between packages.config and package files
_logger.LogWarning($"Could not find existing local files for installed '{package.Id}'. Continue update to version '{updateIdentity.Version}'");
ValidatePackage(package);
_packageOperationNotificationService.NotifyOperationStarting(installPath, PackageOperationType.Install, package);
await _nuGetPackageManager.UpdatePackageForProjectAsync(_defaultProject, updateIdentity.Id, updateIdentity.Version, token);
return;
}
var uninstallPath = _defaultProject.GetInstallPath(currentIdentity);
try
{
ValidatePackage(package);
_packageOperationNotificationService.NotifyOperationStarting(installPath, PackageOperationType.Update, package); // install path is same as update
// notify about uninstall and install because update in fact is combination of these actions
// this also allow us provide different InstallPaths on notifications
_packageOperationNotificationService.NotifyOperationStarting(uninstallPath, PackageOperationType.Uninstall, package);
_packageOperationNotificationService.NotifyOperationStarting(installPath, PackageOperationType.Install, package);
await _nuGetPackageManager.UpdatePackageForProjectAsync(_defaultProject, updateIdentity.Id, updateIdentity.Version, token);
}
catch (Exception ex)
{
await _logger.LogAsync(LogLevel.Error, ex.Message);
_packageOperationContextService.CurrentContext.Exceptions.Add(ex);
}
finally
{
FinishOperation(PackageOperationType.Uninstall, uninstallPath, package);
FinishOperation(PackageOperationType.Install, installPath, package);
FinishOperation(PackageOperationType.Update, installPath, package); // The install path the same for update;
}
}
private void ValidatePackage(IPackageDetails package)
{
package.ResetValidationContext();
_apiPackageRegistry.Validate(package);
if (package.ValidationContext.GetErrorCount(ValidationTags.Api) > 0)
{
throw new ApiValidationException(package.ValidationContext.GetErrors(ValidationTags.Api).First().Message);
}
}
private bool CanUpdate(IPackageDetails package)
{
Argument.IsNotNull(() => package);
if (package.IsInstalled == null)
{
var count = _packageQueryService.CountPackages(_localRepository, package);
package.IsInstalled = count != 0;
}
return(!package.IsInstalled.Value);
}
private void UnsubscribeFromDownloadProgress(IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
IWeakEventListener weakEventListener;
if (_packageEvents.TryGetValue(packageDetails, out weakEventListener))
{
weakEventListener.Detach();
_packageEvents.Remove(packageDetails);
}
}
private bool CanInstall(IPackageDetails package)
{
Argument.IsNotNull(() => package);
if (package.IsInstalled == null)
{
var count = _packageQueryService.CountPackages(_localRepository, package.Id);
package.IsInstalled = count != 0;
ValidatePackage(package);
}
return(package.IsInstalled != null && !package.IsInstalled.Value && package.ValidationContext.GetErrorCount(ValidationTags.Api) == 0);
}
public PackageDetailsViewModel(IPackageDetails package, IPackageDetailsService packageDetailsService, IPackageQueryService packageQueryService, IRepositoryNavigatorService repositoryNavigatorService)
{
Argument.IsNotNull(() => package);
Argument.IsNotNull(() => packageDetailsService);
Argument.IsNotNull(() => packageQueryService);
Argument.IsNotNull(() => repositoryNavigatorService);
_packageDetailsService = packageDetailsService;
_packageQueryService = packageQueryService;
_repositoryNavigatorService = repositoryNavigatorService;
Package = package;
}
/// <summary>
/// Sets the forms toolbar buttons visibility based on the display mode of the package.
/// </summary>
/// <param name="form">The package details form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void OnLoadPackageForm(IPackageDetails form, EventArgs args)
{
Sage.Platform.WebPortal.SmartParts.EntityBoundSmartPart smartpart = form.NativeForm as Sage.Platform.WebPortal.SmartParts.EntityBoundSmartPart;
Sage.Platform.WebPortal.EntityPage page = (Sage.Platform.WebPortal.EntityPage)smartpart.Page;
if (page != null)
{
bool bInsertMode = page.ModeId.ToUpper().Equals("INSERT");
form.btnDelete.Visible = !bInsertMode;
form.btnSave.Visible = !bInsertMode;
form.btnInsertSave.Visible = bInsertMode;
form.ctrlstCreateModProps.Visible = !bInsertMode;
}
}
/// <summary>
/// Sets the forms toolbar buttons visibility based on the display mode of the package.
/// </summary>
/// <param name="form">The package details form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void OnLoadPackageForm(IPackageDetails form, EventArgs args)
{
Sage.Platform.WebPortal.SmartParts.EntityBoundSmartPart smartpart = form.NativeForm as Sage.Platform.WebPortal.SmartParts.EntityBoundSmartPart;
Sage.Platform.WebPortal.EntityPage page = (Sage.Platform.WebPortal.EntityPage)smartpart.Page;
if (page != null)
{
bool bInsertMode = page.ModeId.ToUpper().Equals("INSERT");
form.btnDelete.Visible = !bInsertMode;
form.btnSave.Visible = !bInsertMode;
form.btnInsertSave.Visible = bInsertMode;
form.ctrlstCreateModProps.Visible = !bInsertMode;
}
}
public FlowDocument PackageToFlowDocument(IPackageDetails package)
{
Argument.IsNotNull(() => package);
var result = new FlowDocument();
var paragraph = new Paragraph
{
FontSize = 12
};
var autors = GetDetailsRecord("Created by: ", package.Authors.ToArray());
paragraph.Inlines.AddIfNotNull(autors);
var id = GetDetailsRecord("Id: ", package.Id);
paragraph.Inlines.AddIfNotNull(id);
var version = GetDetailsRecord("Version: ", GetVersion(package));
paragraph.Inlines.AddIfNotNull(version);
var published = package.Published;
if (published != null && _repositoryNavigatorService.Navigator.SelectedRepository.OperationType != PackageOperationType.Uninstall)
{
paragraph.Inlines.AddIfNotNull(GetDetailsRecord("Published: ", published.Value.LocalDateTime.ToString(CultureInfo.CurrentCulture.DateTimeFormat)));
}
if (published != null && _repositoryNavigatorService.Navigator.SelectedRepository.OperationType == PackageOperationType.Uninstall)
{
paragraph.Inlines.AddIfNotNull(GetDetailsRecord("Installed: ", published.Value.LocalDateTime.ToString(CultureInfo.CurrentCulture.DateTimeFormat)));
}
var downloads = GetDetailsRecord("Downloads: ", package.DownloadCount.ToString());
paragraph.Inlines.AddIfNotNull(downloads);
if (!string.IsNullOrWhiteSpace(package.Dependencies))
{
var dependencies = GetDetailsRecord("Dependencies: ", package.Dependencies);
paragraph.Inlines.AddIfNotNull(dependencies);
}
result.Blocks.Add(paragraph);
return(result);
}
public void UpdatePackages(IPackageDetails package, bool allowedPrerelease)
{
Argument.IsNotNull(() => package);
Argument.IsOfType(() => package, typeof(PackageDetails));
try
{
var nuGetPackage = ((PackageDetails)package).Package;
_packageManager.UpdatePackage(nuGetPackage, true, allowedPrerelease);
}
catch (Exception exception)
{
_logger.Log(MessageLevel.Error, exception.Message);
_packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception);
}
}
private void ValidateDependency(IPackageDetails package, PackageDependency dependency)
{
SemanticVersion currentVersion;
lock (_syncObj)
{
if (!_apiPackages.TryGetValue(dependency.Id, out currentVersion))
{
return;
}
}
var versionSpec = dependency.VersionSpec;
var minVersion = versionSpec.MinVersion;
if (minVersion != null)
{
if (versionSpec.IsMinInclusive && currentVersion < minVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_1"), package.Id, dependency.Id, dependency.VersionSpec.MinVersion, currentVersion), ValidationTags.Api));
}
if (!versionSpec.IsMinInclusive && currentVersion <= minVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_2"), package.Id, dependency.Id, dependency.VersionSpec.MinVersion, currentVersion), ValidationTags.Api));
}
}
var maxVersion = versionSpec.MaxVersion;
if (maxVersion == null)
{
return;
}
if (versionSpec.IsMaxInclusive && currentVersion > maxVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_3"), package.Id, dependency.Id, dependency.VersionSpec.MaxVersion, currentVersion), ValidationTags.Api));
}
if (!versionSpec.IsMaxInclusive && currentVersion >= maxVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_4"), package.Id, dependency.Id, dependency.VersionSpec.MaxVersion, currentVersion), ValidationTags.Api));
}
}
private async Task OnPackageActionExecuteAsync(IPackageDetails package)
{
if (Navigator.SelectedRepository == null)
{
return;
}
var operation = Navigator.SelectedRepository.OperationType;
await TaskHelper.Run(() => _packageCommandService.Execute(operation, package, Navigator.SelectedRepository, IsPrereleaseAllowed ?? true), true);
if (_packageCommandService.IsRefreshRequired(operation))
{
await CountAndSearchAsync();
}
RefreshCanExecute();
}
public void Validate(IPackageDetails package)
{
Argument.IsNotNull(() => package);
Argument.IsOfType(() => package, typeof(PackageDetails));
var innerPackage = ((PackageDetails)package).Package;
lock (_syncObj)
{
foreach (var dependencySet in innerPackage.DependencySets)
{
foreach (var dependency in dependencySet.Dependencies)
{
ValidateDependency(package, dependency);
}
}
}
}
private void SubscribeToDownloadProgress(IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
var packageDownloader = GetPackageDownloaderInstance(packageDetails);
if (packageDownloader == null)
{
return;
}
var weakEvent = this.SubscribeToWeakGenericEvent <ProgressEventArgs>(packageDownloader, "ProgressAvailable", OnPackageDownloadProgress);
if (weakEvent != null)
{
_packageEvents.Add(packageDetails, weakEvent);
}
}
public FlowDocument PackageToFlowDocument(IPackageDetails package)
{
Argument.IsNotNull(() => package);
var result = new FlowDocument();
var paragraph = new Paragraph
{
FontSize = 12
};
var autors = GetDetailsRecord("Created by: ", package.Authors.ToArray());
paragraph.Inlines.AddIfNotNull(autors);
var id = GetDetailsRecord("Id: ", package.Id);
paragraph.Inlines.AddIfNotNull(id);
var version = GetDetailsRecord("Version: ", GetVersion(package));
paragraph.Inlines.AddIfNotNull(version);
var published = package.Published;
if (published != null && _repositoryNavigatorService.Navigator.SelectedRepository.OperationType != PackageOperationType.Uninstall)
{
paragraph.Inlines.AddIfNotNull(GetDetailsRecord("Published: ", published.Value.LocalDateTime.ToString(CultureInfo.CurrentCulture.DateTimeFormat)));
}
if (published != null && _repositoryNavigatorService.Navigator.SelectedRepository.OperationType == PackageOperationType.Uninstall)
{
paragraph.Inlines.AddIfNotNull(GetDetailsRecord("Installed: ", published.Value.LocalDateTime.ToString(CultureInfo.CurrentCulture.DateTimeFormat)));
}
var downloads = GetDetailsRecord("Downloads: ", package.DownloadCount.ToString());
paragraph.Inlines.AddIfNotNull(downloads);
if (!string.IsNullOrWhiteSpace(package.Dependencies))
{
var dependencies = GetDetailsRecord("Dependencies: ", package.Dependencies);
paragraph.Inlines.AddIfNotNull(dependencies);
}
result.Blocks.Add(paragraph);
return result;
}
public bool CanExecute(PackageOperationType operationType, IPackageDetails package)
{
if (package == null)
{
return(false);
}
switch (operationType)
{
case PackageOperationType.Install:
return(CanInstall(package));
case PackageOperationType.Update:
return(CanUpdate(package));
case PackageOperationType.Uninstall:
return(CanUninstall(package));
}
return(false);
}
public bool CanExecute(PackageOperationType operationType, IPackageDetails package)
{
if (package == null)
{
return false;
}
switch (operationType)
{
case PackageOperationType.Install:
return CanInstall(package);
case PackageOperationType.Update:
return CanUpdate(package);
case PackageOperationType.Uninstall:
return CanUninstall(package);
}
return false;
}
public void InstallPackage(IPackageDetails package, bool allowedPrerelease)
{
Argument.IsNotNull(() => package);
Argument.IsOfType(() => package, typeof (PackageDetails));
var repository = _packageOperationContextService.CurrentContext.Repository;
var sourceRepository = _repositoryCacheService.GetNuGetRepository(repository);
var walker = new InstallWalker(_localRepository, sourceRepository, null, _logger, false, allowedPrerelease, DependencyVersion);
try
{
var nuGetPackage = ((PackageDetails) package).Package;
var operations = walker.ResolveOperations(nuGetPackage);
_packageManager.InstallPackage(nuGetPackage, false, allowedPrerelease, false);
}
catch (Exception exception)
{
_logger.Log(MessageLevel.Error, exception.Message);
_packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception);
}
}
public void UninstallPackage(IPackageDetails package)
{
Argument.IsNotNull(() => package);
Argument.IsOfType(() => package, typeof (PackageDetails));
var dependentsResolver = new DependentsWalker(_localRepository, null);
var walker = new UninstallWalker(_localRepository, dependentsResolver, null,
_logger, true, false);
try
{
var nuGetPackage = ((PackageDetails) package).Package;
var operations = walker.ResolveOperations(nuGetPackage);
_packageManager.UninstallPackage(nuGetPackage, false, true);
}
catch (Exception exception)
{
_logger.Log(MessageLevel.Error, exception.Message);
_packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception);
}
}
private bool CanUninstall(IPackageDetails package)
{
return true;
}
private bool CanUpdate(IPackageDetails package)
{
Argument.IsNotNull(() => package);
if (package.IsInstalled == null)
{
var count = _packageQueryService.CountPackages(_localRepository, package);
package.IsInstalled = count != 0;
}
return !package.IsInstalled.Value;
}
public IEnumerable<IPackageDetails> GetVersionsOfPackage(IRepository packageRepository, IPackageDetails package, bool allowPrereleaseVersions, ref int skip, int minimalTake = 10)
{
Argument.IsNotNull(() => packageRepository);
try
{
var nuGetRepository = _repositoryCacheService.GetNuGetRepository(packageRepository);
return nuGetRepository.FindPackageVersions(package.ToNuGetPackage(), allowPrereleaseVersions, ref skip, minimalTake)
.Select(p => _packageCacheService.GetPackageDetails(p));
}
catch (Exception exception)
{
Log.Warning(exception);
return Enumerable.Empty<PackageDetails>();
}
}
private void SubscribeToDownloadProgress(IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
var packageDownloader = GetPackageDownloaderInstance(packageDetails);
if (packageDownloader == null)
{
return;
}
var weakEvent = this.SubscribeToWeakGenericEvent<ProgressEventArgs>(packageDownloader, "ProgressAvailable", OnPackageDownloadProgress);
if (weakEvent != null)
{
_packageEvents.Add(packageDetails, weakEvent);
}
}
public void UpdatePackages(IPackageDetails package, bool allowedPrerelease)
{
Argument.IsNotNull(() => package);
Argument.IsOfType(() => package, typeof (PackageDetails));
try
{
var nuGetPackage = ((PackageDetails) package).Package;
_packageManager.UpdatePackage(nuGetPackage, true, allowedPrerelease);
}
catch (Exception exception)
{
_logger.Log(MessageLevel.Error, exception.Message);
_packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception);
}
}
private bool OnPackageActionCanExecute(IPackageDetails parameter)
{
if (Navigator.SelectedRepository == null)
{
return false;
}
return _packageCommandService.CanExecute(Navigator.SelectedRepository.OperationType, parameter);
}
private object GetPackageDownloaderInstance(IPackageDetails packageDetails)
{
var innerPackagePropertyInfo = packageDetails.GetType().GetPropertyEx("Package");
if (innerPackagePropertyInfo == null)
{
return null;
}
var innerPackage = innerPackagePropertyInfo.GetValue(packageDetails, null);
if (innerPackage == null)
{
return null;
}
var downloaderPropertyInfo = innerPackage.GetType().GetPropertyEx("Downloader");
if (downloaderPropertyInfo == null)
{
return null;
}
var downloader = downloaderPropertyInfo.GetValue(innerPackage, null);
if (downloader == null)
{
return null;
}
return downloader;
}
private async Task OnPackageActionExecuteAsync(IPackageDetails package)
{
if (Navigator.SelectedRepository == null)
{
return;
}
var operation = Navigator.SelectedRepository.OperationType;
await TaskHelper.Run(() => _packageCommandService.Execute(operation, package, Navigator.SelectedRepository, IsPrereleaseAllowed ?? true), true);
if (_packageCommandService.IsRefreshRequired(operation))
{
await CountAndSearchAsync();
}
RefreshCanExecute();
}
private void UnsubscribeFromDownloadProgress(IPackageDetails packageDetails)
{
Argument.IsNotNull(() => packageDetails);
IWeakEventListener weakEventListener;
if (_packageEvents.TryGetValue(packageDetails, out weakEventListener))
{
weakEventListener.Detach();
_packageEvents.Remove(packageDetails);
}
}
public bool IsNewer(IPackageDetails other)
{
return this.NuGetPackage.Version > ((NuGetPackageDetails)other).NuGetPackage.Version;
}
