private IEnumerable <PackageIdentity> GetConsolidatedPackageIdentityForResolver()
{
PackageIdentity identity = null;
// If Version is specified by commandline parameter
if (!string.IsNullOrEmpty(Version))
{
NuGetVersion nVersion = PowerShellPackage.GetNuGetVersionFromString(Version);
PackageIdentity pIdentity = new PackageIdentity(Id, nVersion);
identity = Client.PackageRepositoryHelper.ResolvePackage(V2LocalRepository, pIdentity, true);
}
else
{
VsProject target = this.GetProject(true);
InstalledPackageReference installedPackage = GetInstalledReference(target, Id);
if (installedPackage == null)
{
Log(MessageLevel.Error, Resources.Cmdlet_PackageNotInstalled, Id);
}
else
{
identity = installedPackage.Identity;
Version = identity.Version.ToNormalizedString();
}
}
return(new List <PackageIdentity>()
{
identity
});
}
protected Dictionary <VsProject, IEnumerable <JObject> > GetPackageUpdatesFromRemoteSource(string filter, bool allowPrerelease, int skip, int take, bool allVersions)
{
IEnumerable <VsProject> targets = GetProjects();
Dictionary <VsProject, IEnumerable <JObject> > packageUpdates = new Dictionary <VsProject, IEnumerable <JObject> >();
foreach (VsProject project in targets)
{
Task <IEnumerable <JObject> > task = project.InstalledPackages.GetAllInstalledPackagesAndMetadata();
IEnumerable <JObject> installedJObjects = task.Result;
List <JObject> filteredUpdates = new List <JObject>();
foreach (JObject jObject in installedJObjects)
{
// Find packages update
List <JObject> updates = PowerShellPackage.GetLastestJObjectsForPackage(ActiveSourceRepository, jObject, project, allowPrerelease, skip, take, allVersions);
NuGetVersion originalVersion = PowerShellPackage.GetNuGetVersionFromString(jObject.Value <string>(Properties.Version));
if (!string.IsNullOrEmpty(filter))
{
updates = updates.Where(p => p.Value <string>(Properties.PackageId).StartsWith(filter, StringComparison.OrdinalIgnoreCase)).ToList();
}
filteredUpdates.AddRange(updates);
}
packageUpdates.Add(project, filteredUpdates);
}
return(packageUpdates);
}
private PackageIdentity ParsePackageIdentityFromHttpSource(string sourceUrl)
{
if (!string.IsNullOrEmpty(sourceUrl))
{
string lastPart = sourceUrl.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault();
lastPart = lastPart.Replace(NuGet.Constants.PackageExtension, "");
string[] parts = lastPart.Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
StringBuilder builderForId = new StringBuilder();
StringBuilder builderForVersion = new StringBuilder();
foreach (string s in parts)
{
int n;
bool isNumeric = int.TryParse(s, out n);
if (!isNumeric)
{
builderForId.Append(s);
builderForId.Append(".");
}
else
{
builderForVersion.Append(s);
builderForVersion.Append(".");
}
}
NuGetVersion nVersion = PowerShellPackage.GetNuGetVersionFromString(builderForVersion.ToString().TrimEnd('.'));
return(new PackageIdentity(builderForId.ToString().TrimEnd('.'), nVersion));
}
return(null);
}
/// <summary>
/// Returns single package identity for resolver when Id is specified
/// </summary>
/// <returns></returns>
private List <PackageIdentity> GetPackageIdentityForResolver()
{
VsProject target = this.GetProject(true);
InstalledPackageReference installedPackage = GetInstalledReference(target, Id);
// If package Id cannot be found in Installed packages.
if (installedPackage == null)
{
WriteError(string.Format(Resources.Cmdlet_PackageNotInstalled, Id));
}
PackageIdentity identity = installedPackage.Identity;
if (!string.IsNullOrEmpty(Version))
{
NuGetVersion nVersion = PowerShellPackage.GetNuGetVersionFromString(Version);
// If specified Version does not match the installed version
if (nVersion != identity.Version)
{
WriteError(string.Format(VsResources.UnknownPackageInProject, Id + " " + Version, target.Name));
}
}
// Finally resolve the identity against local repository.
PackageIdentity resolvedIdentity = Client.PackageRepositoryHelper.ResolvePackage(V2LocalRepository, identity, true);
return(new List <PackageIdentity>()
{
resolvedIdentity
});
}
/// <summary>
/// Returns single package identity for resolver when Id is specified
/// </summary>
/// <returns></returns>
private List <PackageIdentity> GetPackageIdentityForResolver()
{
PackageIdentity identity = null;
// If Version is specified by commandline parameter
if (!string.IsNullOrEmpty(Version))
{
NuGetVersion nVersion = PowerShellPackage.GetNuGetVersionFromString(Version);
PackageIdentity pIdentity = new PackageIdentity(Id, nVersion);
identity = Client.PackageRepositoryHelper.ResolvePackage(ActiveSourceRepository, V2LocalRepository, pIdentity, IncludePrerelease.IsPresent);
}
else
{
// Get the latest Version from package repository.
IEnumerable <FrameworkName> frameworks = this.Projects.FirstOrDefault().GetSupportedFrameworks();
Version = PowerShellPackage.GetLastestVersionForPackage(ActiveSourceRepository, Id, frameworks, IncludePrerelease.IsPresent);
identity = new PackageIdentity(Id, NuGetVersion.Parse(Version));
}
return(new List <PackageIdentity>()
{
identity
});
}
private void PerformPackageUpdates()
{
// UpdateAll
if (!_idSpecified)
{
Dictionary <VsProject, List <PackageIdentity> > dictionary = GetInstalledPackagesForAllProjects();
foreach (KeyValuePair <VsProject, List <PackageIdentity> > entry in dictionary)
{
IEnumerable <VsProject> targetedProjects = new List <VsProject> {
entry.Key
};
List <PackageIdentity> identities = entry.Value;
// Execute update for each of the project inside the solution
foreach (PackageIdentity identity in identities)
{
// Find packages update
PackageIdentity update = PowerShellPackage.GetLastestUpdateForPackage(ActiveSourceRepository, identity, entry.Key, IncludePrerelease.IsPresent, Safe.IsPresent);
ExecuteSinglePackageAction(update, targetedProjects);
}
}
}
else
{
// Resolve package Id to be updated from the local repository
PackageIdentity installedIdentity = new PackageIdentity(Id, null);
Client.PackageRepositoryHelper.ResolvePackage(V2LocalRepository, installedIdentity, IncludePrerelease.IsPresent);
Dictionary <VsProject, PackageIdentity> dictionary = GetInstalledPackageWithId(Id);
// If package Id exists in Packages folder but is not actually installed to the current project, throw.
if (dictionary.Count == 0)
{
WriteError(string.Format(VsResources.PackageNotInstalledInAnyProject, Id));
}
foreach (KeyValuePair <VsProject, PackageIdentity> entry in dictionary)
{
IEnumerable <VsProject> targetedProjects = new List <VsProject> {
entry.Key
};
PackageIdentity identity = entry.Value;
PackageIdentity update = null;
// Find package update
if (!string.IsNullOrEmpty(Version))
{
NuGetVersion nVersion;
if (IsVersionEnum)
{
nVersion = PowerShellPackage.GetUpdateVersionForDependentPackage(ActiveSourceRepository, identity, UpdateVersionEnum, entry.Key.GetSupportedFrameworks(), IncludePrerelease.IsPresent);
}
else
{
nVersion = PowerShellPackage.GetNuGetVersionFromString(Version);
}
if (nVersion != null)
{
PackageIdentity pIdentity = new PackageIdentity(Id, nVersion);
update = Client.PackageRepositoryHelper.ResolvePackage(ActiveSourceRepository, V2LocalRepository, pIdentity, IncludePrerelease.IsPresent);
}
}
else
{
update = PowerShellPackage.GetLastestUpdateForPackage(ActiveSourceRepository, identity, entry.Key, IncludePrerelease.IsPresent, Safe.IsPresent);
if (update.Version <= identity.Version)
{
update = null;
Log(MessageLevel.Info, Resources.Cmdlet_NoPackageUpdates);
}
}
ExecuteSinglePackageAction(update, targetedProjects);
}
}
}
