public override void Run()
{
var commandLine = PaketCommandLine.CreateCommandLine("restore");
var message = ProgressMonitorStatusMessageFactory.CreateRestoreMessage();
PaketServices.CommandRunner.Run(commandLine, message);
}
public override void Run()
{
var commandLine = PaketCommandLine.CreateCommandLine("auto-restore on");
var message = ProgressMonitorStatusMessageFactory.CreateAutoRestoreOnMessage();
PaketServices.CommandRunner.Run(commandLine, message, NotifyAllProjectFilesChangedInSolution);
}
void RestorePackages(IEnumerable <DotNetProject> projects)
{
var actions = projects.Select(project => new RestoreNuGetPackagesInDotNetCoreProject(project)).ToList();
var message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInProjectMessage();
PackageManagementServices.BackgroundPackageActionRunner.Run(message, actions);
}
public override void Run()
{
var commandLine = PaketCommandLine.CreateCommandLine("convert-from-nuget");
var message = ProgressMonitorStatusMessageFactory.CreateConvertFromNuGetMessage();
PaketServices.CommandRunner.Run(commandLine, message, NotifyAllPaketAndProjectFilesChangedInSolution);
}
public void Update()
{
var message = ProgressMonitorStatusMessageFactory.CreateUpdateMessage();
var action = new UpdatePaketAction(FolderNode.GetPaketDependenciesFile());
PaketServices.ActionRunner.Run(message, action);
}
public override void Run()
{
var commandLine = PaketCommandLine.CreateCommandLine("install");
var message = ProgressMonitorStatusMessageFactory.CreateInstallMessage();
PaketServices.CommandRunner.Run(commandLine, message, NotifyAllPaketAndProjectFilesChangedInSolution);
}
ProgressMonitorStatusMessage CreateProgressMessage(List <UpdatePackageAction> updateActions)
{
if (updateActions.Count == 1)
{
return(ProgressMonitorStatusMessageFactory.CreateUpdatingSinglePackageMessage(updateActions.First().PackageId));
}
return(ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInProjectMessage(updateActions.Count));
}
ProgressMonitorStatusMessage CreateProgressMessage(IEnumerable <ReinstallPackageAction> actions)
{
if (actions.Count() == 1)
{
return(ProgressMonitorStatusMessageFactory.CreateRetargetingSinglePackageMessage(actions.First().PackageId));
}
return(ProgressMonitorStatusMessageFactory.CreateRetargetingPackagesInProjectMessage(actions.Count()));
}
void RestorePackages(DotNetProject project)
{
ProgressMonitorStatusMessage message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInProjectMessage();
var action = new RestoreNuGetPackagesInDotNetCoreProject(project);
action.ReloadProject = true;
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
}
public override void Run()
{
Solution solution = IdeApp.ProjectOperations.CurrentSelectedSolution;
var commandLine = PaketCommandLine.CreateCommandLine("init");
var message = ProgressMonitorStatusMessageFactory.CreateInitMessage();
PaketServices.CommandRunner.Run(commandLine, message, () => NotifyPaketDependencyFileChanged(solution));
}
public override void Run()
{
var commandLine = PaketCommandLine.CreateCommandLine("outdated");
var message = ProgressMonitorStatusMessageFactory.CreateOutdatedMessage();
AggregatedProgressMonitor progressMonitor = CreateProgressMonitor(message);
PaketConsolePad.Show(progressMonitor);
PaketServices.CommandRunner.Run(commandLine, message, progressMonitor);
}
public void Update()
{
var message = ProgressMonitorStatusMessageFactory.CreateUpdateNuGetPackageMessage(DependencyNode.Id);
var action = new UpdateNuGetPaketAction(
DependencyNode.Id,
DependencyNode.GetPackageDependencyFile());
PaketServices.ActionRunner.Run(message, action);
}
protected override void Run()
{
try {
Update();
} catch (Exception ex) {
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInSolutionMessage();
PackageManagementServices.BackgroundPackageActionRunner.ShowError(progressMessage, ex);
}
}
void Update()
{
var updateAllPackages = new UpdateAllNuGetPackagesInSolution(GetSelectedSolution());
List <IPackageAction> updateActions = updateAllPackages.CreateActions().ToList();
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInSolutionMessage(updateAllPackages.GetProjects());
PackageManagementServices.BackgroundPackageActionRunner.Run(progressMessage, updateActions);
}
public static void Run(DotNetProject project)
{
try {
ProgressMonitorStatusMessage message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInProjectMessage();
IPackageAction action = CreateRestorePackagesAction(project);
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
} catch (Exception ex) {
ShowStatusBarError(ex);
}
}
protected override void Run()
{
try {
ProgressMonitorStatusMessage message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInSolutionMessage();
var action = new RestoreNuGetPackagesAction(GetSelectedSolution());
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
} catch (Exception ex) {
ShowStatusBarError(ex);
}
}
void Update()
{
var solutionManager = PackageManagementServices.Workspace.GetSolutionManager(GetSelectedSolution());
var project = GetSelectedDotNetProject();
var action = new UpdateAllNuGetPackagesInProjectAction(solutionManager, project);
var progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInProjectMessage(new DotNetProjectProxy(project));
PackageManagementServices.BackgroundPackageActionRunner.Run(progressMessage, action);
}
void RemoveMultiplePackages(PackageDependencyNode[] nodes)
{
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateRemovingPackagesFromProjectMessage(nodes.Length);
try {
RemoveMultiplePackage(nodes, progressMessage);
} catch (Exception ex) {
PackageManagementServices.BackgroundPackageActionRunner.ShowError(progressMessage, ex);
}
}
protected override void Run()
{
try {
ProgressMonitorStatusMessage message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInProjectMessage();
IPackageAction action = CreateRestorePackagesAction(GetSelectedDotNetProject());
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
} catch (Exception ex) {
ShowStatusBarError(ex);
}
}
public static void Run(DotNetProject project, bool restoreTransitiveProjectReferences, bool reevaluateBeforeRestore = false)
{
try {
ProgressMonitorStatusMessage message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInProjectMessage();
IPackageAction action = CreateRestorePackagesAction(project, restoreTransitiveProjectReferences, reevaluateBeforeRestore);
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
} catch (Exception ex) {
ShowStatusBarError(ex);
}
}
public override void DeleteItem()
{
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateRemoveNuGetPackageMessage(ReferenceNode.Id);
try {
RemovePackageReference(progressMessage);
} catch (Exception ex) {
PaketServices.ActionRunner.ShowError(progressMessage, ex);
}
}
public void CheckForUpdates()
{
var message = ProgressMonitorStatusMessageFactory.CreateUpdatedPackagesMessage();
var action = new CheckForUpdatesPaketAction(
message,
FolderNode.GetPaketDependenciesFile(),
OnCheckForUpdatesCompleted);
PaketServices.ActionRunner.Run(message, action);
}
public override void DeleteItem()
{
var packageReferenceNode = (PackageReferenceNode)CurrentNode.DataItem;
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateRemoveSinglePackageMessage(packageReferenceNode.Id);
try {
RemovePackage(packageReferenceNode, progressMessage);
} catch (Exception ex) {
PackageManagementServices.BackgroundPackageActionRunner.ShowError(progressMessage, ex);
}
}
void AddPackagesToProject(DotNetProject project, IList <NuGetPackageToAdd> packagesToAdd)
{
var message = ProgressMonitorStatusMessageFactory.CreateAddNuGetPackagesMessage(packagesToAdd);
List <PaketAction> actions = packagesToAdd
.Select(package => new AddNuGetToProjectPaketAction(package, project))
.OfType <PaketAction> ()
.ToList();
actions.Insert(0, new CreatePaketDependenciesFileIfNotExistPaketAction(project));
PaketServices.ActionRunner.Run(message, actions);
}
protected override void Run()
{
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInSolutionMessage();
try {
UpdateAllPackagesInSolution updateAllPackages = CreateUpdateAllPackagesInSolution();
List <UpdatePackageAction> updateActions = updateAllPackages.CreateActions().ToList();
PackageManagementServices.BackgroundPackageActionRunner.Run(progressMessage, updateActions);
} catch (Exception ex) {
PackageManagementServices.BackgroundPackageActionRunner.ShowError(progressMessage, ex);
}
}
static void RestorePackages(Solution solution, Action <RestoreNuGetPackagesAction> modifyRestoreAction)
{
Runtime.AssertMainThread();
try {
ProgressMonitorStatusMessage message = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesInSolutionMessage();
var action = new RestoreNuGetPackagesAction(solution);
modifyRestoreAction(action);
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
} catch (Exception ex) {
ShowStatusBarError(ex);
}
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
Runtime.RunInMainThread(delegate {
var action = new UninstallNuGetPackageAction(
PackageManagementServices.Workspace.GetSolutionManager(project.ParentSolution),
new DotNetProjectProxy((DotNetProject)project))
{
PackageId = packageId,
RemoveDependencies = removeDependencies
};
var message = ProgressMonitorStatusMessageFactory.CreateRemoveSinglePackageMessage(packageId);
PackageManagementServices.BackgroundPackageActionRunner.Run(message, action);
});
}
void AddPackages(IList <NuGetPackageToAdd> packagesToAdd)
{
if (!packagesToAdd.Any())
{
return;
}
var message = ProgressMonitorStatusMessageFactory.CreateAddNuGetPackagesMessage(packagesToAdd);
List <AddNuGetToProjectPaketAction> actions = packagesToAdd
.Select(package => new AddNuGetToProjectPaketAction(package, FolderNode.Project))
.ToList();
PaketServices.ActionRunner.Run(message, actions);
}
public void UpdatePackage()
{
var packageReferenceNode = (PackageReferenceNode)CurrentNode.DataItem;
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingSinglePackageMessage(packageReferenceNode.Id);
try {
IPackageManagementProject project = PackageManagementServices.Solution.GetActiveProject();
UpdatePackageAction action = project.CreateUpdatePackageAction();
action.PackageId = packageReferenceNode.Id;
PackageManagementServices.BackgroundPackageActionRunner.Run(progressMessage, action);
} catch (Exception ex) {
PackageManagementServices.BackgroundPackageActionRunner.ShowError(progressMessage, ex);
}
}
protected override void Run()
{
try {
UpdateAllPackagesInSolution updateAllPackages = CreateUpdateAllPackagesInSolution();
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInSolutionMessage(updateAllPackages.Projects);
RestoreBeforeUpdateAction.Restore(updateAllPackages.Projects, () => {
Runtime.RunInMainThread(() => {
Update(updateAllPackages, progressMessage);
}).Wait();
});
} catch (Exception ex) {
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateUpdatingPackagesInSolutionMessage();
PackageManagementServices.BackgroundPackageActionRunner.ShowError(progressMessage, ex);
}
}
