private void LookThroughDependencies(NugetFeedPackage nugetFeedPackage, StringBuilder csprojString, NugetFeedPackage[] nugetFeedPackages, string spacing)
{
foreach (var nugetPackage in nugetFeedPackage.Dependencies)
{
var nugetFeedPackageDependency = nugetFeedPackages.SingleOrDefault(p => nugetPackage.Id == p.Id);
if (nugetFeedPackageDependency != null)
{
NugetVersion dependencyVersion2;
NugetVersion nugetFeedPackageVersion2;
try
{
dependencyVersion2 = NugetVersion.FromString(nugetPackage.Version);
nugetFeedPackageVersion2 = NugetVersion.FromString(nugetFeedPackageDependency.Version);
}
catch (FormatException)
{
continue;
}
if (dependencyVersion2.Prerelease || dependencyVersion2 != nugetFeedPackageVersion2)
{
csprojString.AppendLine($"{spacing}{nugetPackage.Id} {nugetPackage.Version} => {nugetFeedPackageDependency.Version}" + (dependencyVersion2.Prerelease ? " [PRERELEASE]" : ""));
// recursive call
LookThroughDependencies(nugetFeedPackageDependency, csprojString, nugetFeedPackages, " " + spacing);
}
}
}
}
private void UpdateProjectNugetPackage(Project foundProject)
{
var reader = new FileReaderContext(foundProject);
bool found = reader.TryGetPackageVersion(NugetPackage, out string packageVersion);
if (found && !NugetVersion.Equals(packageVersion))
{
var writer = new FileWriterContext(foundProject);
writer.UpdateNugetPackage(NugetPackage, NugetVersion);
}
}
private async Task <NugetVersion> GetLatestVersionAndSourceInfoAsync(string packageName, bool includePreRelease)
{
NugetVersion currentNugetVersion = null;
foreach (var sourceInfo in sourceInfos)
{
WriteLineIfVerbose($"Searching for '{packageName}' on '{sourceInfo.Source.Name}'...");
NugetVersion latestNugetVersion;
try
{
latestNugetVersion = await sourceInfo.GetPackageAsync(packageName, null, includePreRelease);
}
catch (Exception ex)
{
WriteLine($"Error when getting '{packageName}'. Source used: '{sourceInfo.Source.Name}'.");
WriteLineIfVerbose($"Error details: {ex.ToString()}'.");
return(null);
}
if (latestNugetVersion == null)
{
WriteLineIfVerbose($"Could not get a version for '{packageName}' on '{sourceInfo.Source.Name}'.");
continue;
}
else
{
WriteLineIfVerbose($"Found version '{latestNugetVersion.Version}' for '{packageName}' on '{sourceInfo.Source.Name}'.");
}
if (currentNugetVersion == null || latestNugetVersion.Version > currentNugetVersion.Version)
{
currentNugetVersion = latestNugetVersion;
}
}
if (currentNugetVersion == null)
{
WriteLine($"Package '{packageName}' not found. Sources used:");
foreach (var source in sourceInfos.Select(p => p.Source))
{
WriteLine($" - {source.Name}: {source.Source}");
}
return(null);
}
WriteLineIfVerbose($"Latest version for '{packageName}' is '{currentNugetVersion.Version}' from '{currentNugetVersion.SourceInfo.Source.Name}'.");
return(currentNugetVersion);
}
public async Task <NugetVersion> GetPackageAsync(string packageName, SemanticVersion packageVersion, bool includePreRelease)
{
var currentFeed = await GetFeedAsync();
if (currentFeed == null)
{
WriteLine("Current feed is null. Returning.");
return(null);
}
var searchQueryServiceUrl = currentFeed.Resources.FirstOrDefault(r => r.Type == "SearchQueryService")?.Id;
if (searchQueryServiceUrl == null)
{
searchQueryServiceUrl = currentFeed.Resources.FirstOrDefault(r => r.Type == "SearchQueryService/3.0.0-rc")?.Id;
}
string serviceUrl;
bool supportsQueryById;
if (searchQueryServiceUrl == null)
{
searchQueryServiceUrl = currentFeed.Resources.FirstOrDefault(r => r.Type == "SearchQueryService/3.0.0-beta")?.Id; //vsts is still in this version
if (searchQueryServiceUrl == null)
{
WriteLine("Nuget server does not offer a search query service we can work with.");
return(null);
}
serviceUrl = $"{searchQueryServiceUrl}?q={packageName}{(includePreRelease ? "&prerelease=true" : "")}";
supportsQueryById = false;
}
else
{
serviceUrl = $"{searchQueryServiceUrl}?q=packageid:{packageName}{(includePreRelease ? "&prerelease=true" : "")}";
supportsQueryById = true;
}
var serviceResponse = await HttpClient.GetAsync(serviceUrl);
if (!serviceResponse.IsSuccessStatusCode)
{
WriteLine($"Could not get service details from '{serviceUrl}'.");
WriteLineIfVerbose($"Got status code: '{(int)serviceResponse.StatusCode}' ({serviceResponse.StatusCode}).");
throw new Exception($"Could not get service details from '{serviceUrl}'.");
}
var serviceContent = await serviceResponse.Content.ReadAsStringAsync();
var service = await Task.Factory.StartNew(() => JsonConvert.DeserializeObject <Service>(serviceContent));
var serviceData = supportsQueryById
? service.Data.FirstOrDefault()
: service.Data.FirstOrDefault(sd => string.Compare(sd.Id, packageName, true) == 0);
var latest = serviceData?.Version;
if (latest == null)
{
WriteLineIfVerbose($"There was no package info for '{packageName}' on '{Source.Name}'.");
return(null);
}
WriteLineIfVerbose($"Found package '{packageName}' with latest version {latest}.");
var currentSemanticVersion = SemanticVersion.Parse(latest);
if (packageVersion != null)
{
var versionExists = serviceData.Versions.Any(v => v.Version == packageVersion.ToString());
if (versionExists)
{
currentSemanticVersion = packageVersion;
}
else
{
WriteLineIfVerbose($"Version '{packageVersion.ToString()}' was not found for '{packageName}' on '{Source.Name}'.");
return(null);
}
}
var nugetVersion = new NugetVersion(currentSemanticVersion, this, serviceData.Id);
return(nugetVersion);
}
public IActionResult ListUpdates(string nugetFeed, string[] projectFilter = null, string searchFilter = null)
{
projectFilter = projectFilter ?? new string[0];
searchFilter = (searchFilter ?? "").ToLowerInvariant();
if (ViewBag.HasConfig = BaseProvider.ConfigProvider.HasConfig())
{
var nugetFeedTask = Task.Run(() =>
{
var nugetReader = new NugetFeedReader(nugetFeed);
nugetReader.FetchPackages();
nugetReader.FilterToLatestPackages();
return(nugetReader.GetCurrentCollection().ToArray());
});
Task <Tuple <IProjectReference, Dictionary <Tuple <IProjectFile, IProjectInformation>, NugetDependency[]> > > FetchAllNugetDependencies(IProjectSource projectSource, IProjectReference project)
{
return(Task.Run(() =>
{
try
{
var nugetDep = projectSource.GetAllNugetDependencies(project, false);
return new Tuple <IProjectReference, Dictionary <Tuple <IProjectFile, IProjectInformation>, NugetDependency[]> >(project, nugetDep);
}
catch (Exception ex)
{
throw new Exception("Failed for project: " + project.GetName(), ex);
}
}));
}
BaseProvider.InitializeProjectSource();
var source = BaseProvider.ProjectSource;
var projectTask = Task.Run(() =>
{
var projects = source.GetAllProjects(false);
if (!string.IsNullOrWhiteSpace(searchFilter))
{
projects = projects.Where(x => x.GetName().ToLowerInvariant().Contains(searchFilter)).ToArray();
}
if (projectFilter.Length > 0)
{
projects = projects.Where(x => projectFilter.Contains(x.GetName())).ToArray();
}
var tasks = projects.Select(project => FetchAllNugetDependencies(source, project)).ToList();
Task.WhenAll(tasks).Wait();
return(tasks.Select(x => x.Result).ToArray());
});
nugetFeedTask.Wait();
projectTask.Wait();
var resultString = new StringBuilder();
foreach (var project in projectTask.Result)
{
var projectReference = project.Item1;
var projectString = new StringBuilder();
foreach (var nugetDependencies in project.Item2)
{
var csprojString = new StringBuilder();
foreach (var nugetDependency in nugetDependencies.Value)
{
var nugetFeedPackage = nugetFeedTask.Result.SingleOrDefault(nfp => nfp.Id == nugetDependency.Id);
if (nugetFeedPackage == null)
{
continue;
}
/*var projects = source.GetAllProjects(false);
* foreach (var reference in projects)
* {
* var definitions = source.GetAllNugetDefinitions(reference, false);
* foreach (var keyValuePair in definitions)
* {
* keyValuePair.Value.Id ==
* }
* }*/
NugetVersion dependencyVersion;
try
{
dependencyVersion = NugetVersion.FromString(nugetDependency.Version);
}
catch (FormatException)
{
csprojString.AppendLine($":{nugetDependency.Id} ERROR: Invalid format [dependency] {nugetDependency.Version}");
continue;
}
NugetVersion nugetFeedPackageVersion;
try
{
nugetFeedPackageVersion = NugetVersion.FromString(nugetFeedPackage.Version);
}
catch (FormatException)
{
csprojString.AppendLine($":{nugetDependency.Id} ERROR: Invalid format [nugetFeed] {nugetFeedPackage.Version}");
continue;
}
if (dependencyVersion.Prerelease || dependencyVersion != nugetFeedPackageVersion)
{
csprojString.AppendLine($"{nugetDependency.Id} {nugetDependency.Version} => {nugetFeedPackage.Version}" + (dependencyVersion.Prerelease ? " [PRERELEASE]" : ""));
LookThroughDependencies(nugetFeedPackage, csprojString, nugetFeedTask.Result, " - ");
}
}
if (csprojString.Length > 0)
{
projectString.AppendLine("Csproj: " + nugetDependencies.Key.Item2.CsprojFilePath);
projectString.AppendLine(" " + csprojString.ToString().Replace("\n", "\n ").TrimEnd());
}
}
var str = projectString.ToString();
if (str.Length > 0)
{
resultString.AppendLine(projectReference.GetName());
resultString.AppendLine(" " + projectString.ToString().Replace("\n", "\n ").TrimEnd());
resultString.AppendLine();
}
}
return(Content(resultString.ToString()));
}
return(Content("Missing config/setup"));
}
