public void Example()
{
#region Usage
NuGetPackage p1 = new NuGetPackage
{
PackageId = "Newtonsoft.Json",
Version = new Version(10, 0, 4)
};
string json = JsonConvert.SerializeObject(p1, Formatting.Indented, new VersionConverter());
Console.WriteLine(json);
// {
// "PackageId": "Newtonsoft.Json",
// "Version": "10.0.4"
// }
NuGetPackage p2 = JsonConvert.DeserializeObject <NuGetPackage>(json, new VersionConverter());
Console.WriteLine(p2.Version.ToString());
// James
#endregion
Assert.AreEqual("10.0.4", p2.Version.ToString());
}
public async Task GetPrereleaseVersionsToDelete_MinIsLatestRelease_UnreleasedTip()
{
_mockHttp.When("https://azuresearch-usnc.nuget.org/query?q=packageid:L10NSharp&prerelease=true")
.Respond("application/json", responseJsonBegin + "4.0.3-beta0003" +
responseJsonMiddle + @"
{
""version"": ""4.0.2-beta0001"",
""downloads"": 0,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.2-beta0001.json""
},
{
""version"": ""4.0.2"",
""downloads"": 28,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.2.json""
},
{
""version"": ""4.0.3-beta0002"",
""downloads"": 0,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.3-beta0002.json""
},
{
""version"": ""4.0.3-beta0003"",
""downloads"": 0,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.3-beta0003.json""
}" + responseJsonEnd);
NuGetPackage.HttpClient = _mockHttp.ToHttpClient();
var sut = new NuGetPackage("L10NSharp", min: "4.0.2");
Assert.That(await sut.GetPrereleaseVersionsToDelete(), Is.Empty);
}
public async Task GetPrereleaseVersionsToDelete_TipIsUnreleased_PreviousUnreleased()
{
_mockHttp.When("https://azuresearch-usnc.nuget.org/query?q=packageid:L10NSharp&prerelease=true")
.Respond("application/json", responseJsonBegin + "4.0.3-beta0003" +
responseJsonMiddle + @"
{
""version"": ""4.0.2-beta0002"",
""downloads"": 0,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.2-beta0002.json""
},
{
""version"": ""4.0.2"",
""downloads"": 28,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.2.json""
},
{
""version"": ""4.0.3-beta0003"",
""downloads"": 0,
""@id"": ""https://api.nuget.org/v3/registration3/l10nsharp/4.0.3-beta0003.json""
}" + responseJsonEnd);
NuGetPackage.HttpClient = _mockHttp.ToHttpClient();
var sut = new NuGetPackage("L10NSharp");
Assert.That(await sut.GetPrereleaseVersionsToDelete(),
Is.EquivalentTo(new [] { SemanticVersion.Parse("4.0.2-beta0002") }));
}
protected async override void OnPropertyChanged(AdvancedPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
if (string.Equals(e.PropertyName, nameof(SelectedVersion)))
{
if ((e.OldValue is null && SelectedVersion == Package.Identity.Version) || e.NewValue is null)
{
// Skip loading on version list first load
return;
}
var identity = new PackageIdentity(Package.Identity.Id, SelectedVersion);
VersionData = await LoadSinglePackageMetadataAsync(identity, Package, _settingsProvider.Model.IsPreReleaseIncluded);
if (Package is not null)
{
// Note: Workaround, this is a hack way to set specific version of package
var tempPackage = new NuGetPackage(VersionData, Package.FromPage);
tempPackage.AddDependencyInfo(VersionData.Identity.Version, VersionData.DependencySets);
ValidateCurrentPackage(tempPackage);
}
}
}
public Boolean Is(NuGetPackage nugetPackage)
{
if (nugetPackage.Id != Id)
{
return(false);
}
var nugetVersion = new PackageVersion(nugetPackage.Version);
if (!String.IsNullOrWhiteSpace(Version) && new PackageVersion(Version) == nugetVersion)
{
return(true);
}
bool?before = null;
bool?after = null;
if (!String.IsNullOrWhiteSpace(Before))
{
before = new PackageVersion(Before) > nugetVersion;
}
if (!String.IsNullOrWhiteSpace(BeforeOrAt))
{
before = new PackageVersion(BeforeOrAt) >= nugetVersion;
}
if (!String.IsNullOrWhiteSpace(After))
{
after = new PackageVersion(After) < nugetVersion;
}
if (!String.IsNullOrWhiteSpace(AfterOrAt))
{
after = new PackageVersion(AfterOrAt) <= nugetVersion;
}
return(before.HasValue && before.Value && after.HasValue && after.Value ||
!before.HasValue && after.HasValue && after.Value ||
before.HasValue && before.Value && !after.HasValue);
}
private IFile[] InstallPackage(
NuGetPackage package,
DirectoryPath installationRoot,
Func <DirectoryPath, IFile[]> fetcher)
{
var root = _fileSystem.GetDirectory(installationRoot);
var packagePath = installationRoot.Combine(package.PackageId);
// Create the addin directory if it doesn't exist.
if (!root.Exists)
{
_log.Debug("Creating addin directory {0}", installationRoot);
root.Create();
}
// Fetch available content from disc.
var content = fetcher(packagePath);
if (content.Any())
{
_log.Debug("Package {0} has already been installed.", package.PackageId);
return(content);
}
// Install the package.
_log.Debug("Installing package {0}...", package.PackageId);
_installer.InstallPackage(package, installationRoot);
// Return the files.
return(fetcher(packagePath));
}
public void NuGet_ActualExample()
{
string testDir = TestUtils.CreateTestDirectory(this.TestContext);
string filePath = TestUtils.CreateTextFile("diagnostic.txt", testDir,
@"<?xml version=""1.0""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd"">
<metadata>
<id>ExampleAnalyzer1</id>
<version>1.0.0.0</version>
<title>ExampleAnalyzer1</title>
<authors>duncanp</authors>
<owners>duncanp</owners>
<licenseUrl>http://LICENSE_URL_HERE_OR_DELETE_THIS_LINE</licenseUrl>
<projectUrl>http://PROJECT_URL_HERE_OR_DELETE_THIS_LINE</projectUrl>
<iconUrl>http://ICON_URL_HERE_OR_DELETE_THIS_LINE</iconUrl>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<description>ExampleAnalyzer1</description>
<releaseNotes>Summary of changes made in this release of the package.</releaseNotes>
<copyright>Copyright</copyright>
<tags>ExampleAnalyzer1, analyzers</tags>
</metadata>
<!-- The convention for analyzers is to put language agnostic dlls in analyzers\dotnet and language specific analyzers in either analyzers\dotnet\cs or analyzers\dotnet\vb -->
<files>
<file src=""*.dll"" target=""analyzers\dotnet\cs"" exclude=""**\Microsoft.CodeAnalysis.*;**\System.Collections.Immutable.*;**\System.Reflection.Metadata.*;**\System.Composition.*"" />
<file src=""tools\*.ps1"" target=""tools\"" />
</files>
</package>");
NuGetPackage pkg = NuGetPackage.Load(filePath);
Assert.IsNotNull(pkg.Metadata);
Assert.IsNotNull(pkg.Files);
Assert.AreEqual(2, pkg.Files.Items.Count, "Unexpected number of files");
}
private bool TryAddPackageTreeToProjectUpgradeConfigSection(XmlDocument powerShellXmlConfig, XmlElement projectNode, string projectFilePath, NuGetPackage currentSitefinityVersionPackage, NuGetPackage newSitefinityVersionPackageTree)
{
bool packageExists = this.sitefinityPackageManager.PackageExists(currentSitefinityVersionPackage.Id, projectFilePath);
if (!packageExists)
{
return(false);
}
NuGetPackage newSitefinityVersionPackage = this.FindNuGetPackageByIdInDependencyTree(newSitefinityVersionPackageTree, currentSitefinityVersionPackage.Id);
if (newSitefinityVersionPackage == null)
{
this.logger.LogWarning($"New version for package '{currentSitefinityVersionPackage.Id}' was not found. Package will not be upgraded.");
return(false);
}
this.AddPackageNodeToProjectUpgradeConfigSection(powerShellXmlConfig, projectNode, newSitefinityVersionPackage);
// Add the NuGet package and all of its dependencies to the cache, because those packages will be upgraded as dependencies of the root package
this.AddNuGetPackageTreeToCache(projectFilePath, newSitefinityVersionPackage);
return(true);
}
/// <summary>
/// Executes the specified resource with the specific context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// <see cref="IResourceResult" /> that can be executed when the Http response is ready to be returned.
/// </returns>
public IResourceResult Execute(IResourceContext context)
{
var packages = NuGetPackage.GetRegisteredPackageVersions();
var stamp = context.Parameters.GetValueOrDefault(ResourceParameter.Timestamp.Name);
var callback = context.Parameters.GetValueOrDefault(ResourceParameter.Callback.Name);
var data = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(stamp))
{
data.Add("stamp", stamp);
}
if (!string.IsNullOrEmpty(callback))
{
data.Add("callback", callback);
}
if (packages.Count > 0)
{
data.Add("packages", packages);
}
var domain = ConfigurationManager.AppSettings["GlimpseVersionCheckAPIDomain"];
if (string.IsNullOrEmpty(domain))
{
domain = "getGlimpse.com";
}
return(new CacheControlDecorator(OneDay, CacheSetting.Public, new RedirectResourceResult(@"//" + domain + "/Api/Version/Check{?packages*}{&stamp}{&callback}", data)));
}
private async Task GenerateProjectUpgradeConfigSection(XmlDocument powerShellXmlConfig, XmlElement powerShellXmlConfigNode, string projectFilePath, NuGetPackage newSitefinityVersionPackageTree, IEnumerable <string> packageSources)
{
XmlElement projectNode = powerShellXmlConfig.CreateElement("project");
XmlAttribute projectNameAttribute = powerShellXmlConfig.CreateAttribute("name");
projectNameAttribute.Value = projectFilePath.Split(new string[] { "\\", Constants.CsprojFileExtension, Constants.VBProjFileExtension }, StringSplitOptions.RemoveEmptyEntries).Last();
projectNode.Attributes.Append(projectNameAttribute);
powerShellXmlConfigNode.AppendChild(projectNode);
Version currentSitefinityVersion = this.DetectSitefinityVersion(projectFilePath);
if (currentSitefinityVersion == null)
{
this.logger.LogInformation($"Skip upgrade for project: '{projectFilePath}'. Current Sitefinity version was not detected.");
return;
}
this.logger.LogInformation($"Detected sitefinity version for '{projectFilePath}' - '{currentSitefinityVersion}'.");
this.logger.LogInformation($"Collecting Sitefinity NuGet package tree for '{projectFilePath}'...");
NuGetPackage currentSitefinityVersionPackageTree = await this.sitefinityPackageManager.GetSitefinityPackageTree(currentSitefinityVersion.ToString(), packageSources);
this.processedPackagesPerProjectCache[projectFilePath] = new HashSet <string>();
if (!this.TryAddPackageTreeToProjectUpgradeConfigSection(powerShellXmlConfig, projectNode, projectFilePath, currentSitefinityVersionPackageTree, newSitefinityVersionPackageTree))
{
await this.ProcessPackagesForProjectUpgradeConfigSection(powerShellXmlConfig, projectNode, projectFilePath, currentSitefinityVersionPackageTree.Dependencies, newSitefinityVersionPackageTree);
}
}
public Dictionary <string, NuGetPackage> GetInstalledPackages(IProject project, XNode xNode)
{
var(prefix, namespaceManager, _) = xNode.Document.GetNamespaceManager();
var packageReferenceElements = xNode.XPathSelectElements($"/{prefix}:Project/{prefix}:ItemGroup/{prefix}:PackageReference", namespaceManager);
return(packageReferenceElements.ToDictionary(
element => element.Attribute("Include")?.Value,
element =>
{
var version = element.XPathSelectElement($"{prefix}:Version", namespaceManager)?.Value;
var privateAssetsElement = element.XPathSelectElement($"{prefix}:PrivateAssets", namespaceManager);
var privateAssets = privateAssetsElement != null
? privateAssetsElement.Value
.Split(';')
.Select(y => y.Trim())
: new string[0];
var includeAssetsElement = element.XPathSelectElement($"{prefix}:IncludeAssets", namespaceManager);
var includeAssets = includeAssetsElement != null
? includeAssetsElement.Value
.Split(';')
.Select(y => y.Trim())
: new string[0];
return NuGetPackage.Create(version, includeAssets, privateAssets);
}));
}
private void GetPackageValidationErrors(NuGetPackage package)
{
Argument.IsNotNull(() => package);
// title: NuGetExplorer_PackageDetailsService_PackageToFlowDocument_GetAlertRecords_Errors
ApiValidationMessages = package.ValidationContext.GetAlertMessages(ValidationTags.Api);
}
public void Maximum(string maximum, int major, int minor, int patch, string release)
{
var sut = new NuGetPackage("L10NSharp", max: maximum);
var expectedVersion = new SemanticVersion(major, minor, patch, release);
Assert.That(sut.Maximum, Is.EqualTo(expectedVersion));
}
protected override async Task <PackageBase> DoResolve(ObservableCollection <PackageBase> packages, string packageId, int depth, CancellationToken token, FrameworkName targetFramework = null, IVersionSpec versionSpec = null)
{
var packageInfo = await m_RepositoryService.Find(packageId, versionSpec);
if (packageInfo == null)
{
return(null);
}
var package = packages.FirstOrDefault(pack => pack.PackageId == packageInfo.Id && pack.VersionInfo == packageInfo.Version);
if (package != null)
{
return(package);
}
if (depth > m_SettingsManager.Settings.MaxSearchDepth)
{
return(null);
}
package = new NuGetPackage(packageInfo.Id, packageInfo.Version, await GetAvailableVersions(packageId))
{
Depth = depth
};
packages.Add(package);
if (token.IsCancellationRequested)
{
return(null);
}
foreach (var dependencySet in packageInfo.DependencySets.Where(set => TargetFrameworkMatch(targetFramework, set)))
{
foreach (var dependency in dependencySet.Dependencies)
{
var resolutionEngine = m_ResolutionFactory.GetResolutionEngine(dependency.Id);
if (resolutionEngine == null)
{
continue;
}
var dependingPackage = await resolutionEngine.Resolve(packages, dependency.Id, depth + 1, token, targetFramework, dependency.VersionSpec) ??
new MissingNuGetPackage(dependency.Id);
package.Dependencies.Add(dependingPackage);
if (token.IsCancellationRequested)
{
break;
}
}
if (token.IsCancellationRequested)
{
break;
}
}
return(package);
}
public Dictionary <string, NuGetPackage> GetInstalledPackages(IProject project, XNode xNode)
{
var packageReferenceElements = xNode.XPathSelectElements("Project/ItemGroup/PackageReference");
return(packageReferenceElements.ToDictionary(
element => element.Attribute("Include")?.Value,
element =>
{
var version = element.Attribute("Version")?.Value;
var privateAssetsElement = element.XPathSelectElement("PrivateAssets");
var privateAssets = privateAssetsElement != null
? privateAssetsElement.Value
.Split(';')
.Select(y => y.Trim())
: new string[0];
var includeAssetsElement = element.XPathSelectElement("IncludeAssets");
var includeAssets = includeAssetsElement != null
? includeAssetsElement.Value
.Split(';')
.Select(y => y.Trim())
: new string[0];
return NuGetPackage.Create(version, includeAssets, privateAssets);
}));
}
private void AddUpdateCommandForXrmUnitTest(List <ProcessExecutorInfo> commands, string packagesPath, string[] packages)
{
var line = packages.FirstOrDefault(p => p.Contains("XrmUnitTest"));
if (line == null)
{
return;
}
var packageId = line.SubstringByString("id=\"", "\"");
var version = new Version(line.SubstringByString("version=\"", "\""));
NuGetPackage newest = null;
if (packageId == GetXrmUnitTestId())
{
// CheckForNewerVersion
newest = PackageLister.GetPackagesbyId(packageId).GetNewest();
if (newest.Version == version)
{
// Latest Version of XrmUnitTest is in use, no need to update
return;
}
}
newest = newest ?? PackageLister.GetPackagesbyId(GetXrmUnitTestId()).GetNewest();
commands.Add(new ProcessExecutorInfo(NuGetPath, $"update \"{packagesPath}\" -NonInteractive -Id {newest.Id} -Version {newest.Version}"));
}
private static void AddNuGetDependency(JObject projectJson, NuGetPackage nugetPackage,
FrameworkName targetFramework)
{
var frameworksObj = GetOrAddJObject(projectJson, "frameworks");
var targetFrameworkObj = GetOrAddJObject(frameworksObj, GetShortFrameworkName(targetFramework));
var dependenciesObj = GetOrAddJObject(targetFrameworkObj, "dependencies");
dependenciesObj[nugetPackage.Identity] = nugetPackage.Version;
}
private async Task <string> GetLicenseContent(NuGetPackage newSitefinityPackage)
{
var pathToPackagesFolder = Path.Combine(Path.GetDirectoryName(this.SolutionPath), Constants.PackagesFolderName);
var pathToTheLicense = Path.Combine(pathToPackagesFolder, $"{newSitefinityPackage.Id}.{newSitefinityPackage.Version}", Constants.LicenseAgreementsFolderName, "License.txt");
var licenseContent = await File.ReadAllTextAsync(pathToTheLicense);
return(licenseContent);
}
public IEnumerable <Task <IEnumerable <bool> > > Upload(NuGetPackage nuGetQueryFilter)
{
return(this.Exec <bool>(async(accessor) =>
{
await accessor.GetResource <PackageUpdateResource>().Push(null, null, 0, false, null, null, false, this.loggerAdapter);
return Enumerable.Empty <bool>();
}));
}
/// <summary>
/// feature
/// </summary>
/// <param name="nuGetQueryFilter"></param>
/// <returns></returns>
internal IEnumerable <Task <IEnumerable <bool> > > Remove(NuGetPackage nuGetQueryFilter)
{
return(this.Exec <bool>(async(accessor) =>
{
await accessor.GetResource <PackageUpdateResource>().Delete(null, null, null, null, false, this.loggerAdapter);
return Enumerable.Empty <bool>();
}));
}
internal void AddPackageReference(NuGetPackage refPackage)
{
if (AllPackageReferences.Any(x => x == refPackage) ||
PackageReferencesFromCsProj.Any(x => x == refPackage.Identity)
)
{
throw new Exceptions.DuplicatePackageReferenceException($"Can't add {refPackage} as SlnX-package reference to the project {Name}, a reference to that package already exists");
}
_packageReferencesFromSlnx.Add(refPackage);
}
public void ActualConverter_ShouldSerialize()
{
var package = new NuGetPackage {
PackageId = new PackageIdentifier("foo")
};
var cut = new PackageIdentifier.JsonNetConverter();
Func <string> serialization = () => JsonConvert.SerializeObject(package, cut);
serialization.Should().NotThrow().Subject.Should().Contain("\"foo\"");
}
public void PackageUrlTest()
{
var pkg = new NuGetPackage
{
Id = "jquery",
Version = "1.5.1"
};
pkg.PackageUrl.Should().BeEquivalentTo("pkg:nuget/[email protected]");
}
private static ListViewItem CreateItem(NuGetPackage package)
{
ListViewItem item = new ListViewItem
{
Content = package.VersionText,
Tag = package
};
return(item);
}
private async Task GeneratePowershellConfig(IEnumerable <string> projectFilePaths, NuGetPackage newSitefinityPackage)
{
this.logger.LogInformation("Exporting powershell config...");
this.packagesPerProject = new Dictionary <string, List <NuGetPackage> >();
var powerShellXmlConfig = new XmlDocument();
var powerShellXmlConfigNode = powerShellXmlConfig.CreateElement("config");
powerShellXmlConfig.AppendChild(powerShellXmlConfigNode);
foreach (string projectFilePath in projectFilePaths)
{
var projectNode = powerShellXmlConfig.CreateElement("project");
var projectNameAttr = powerShellXmlConfig.CreateAttribute("name");
projectNameAttr.Value = projectFilePath.Split(new string[] { "\\", Constants.CsprojFileExtension, Constants.VBProjFileExtension }, StringSplitOptions.RemoveEmptyEntries).Last();
projectNode.Attributes.Append(projectNameAttr);
powerShellXmlConfigNode.AppendChild(projectNode);
packagesPerProject[projectFilePath] = new List <NuGetPackage>();
var currentSitefinityVersion = this.DetectSitefinityVersion(projectFilePath);
if (string.IsNullOrEmpty(currentSitefinityVersion))
{
this.logger.LogInformation(string.Format("Skip upgrade for project: \"{0}\". Current Sitefinity version was not detected.", projectFilePath));
continue;
}
// todo add validation if from version is greater than the to version
this.logger.LogInformation(string.Format("Detected sitefinity version for \"{0}\" - \"{1}\"", projectFilePath, currentSitefinityVersion));
this.logger.LogInformation(string.Format("Collecting Sitefinity NuGet package tree for \"{0}\"...", projectFilePath));
NuGetPackage currentSitefinityPackage = await this.sitefinityPackageManager.GetSitefinityPackageTree(currentSitefinityVersion);
this.IteratePackages(projectFilePath, currentSitefinityPackage, newSitefinityPackage, (package) =>
{
var packageNode = powerShellXmlConfig.CreateElement("package");
var nameAttr = powerShellXmlConfig.CreateAttribute("name");
nameAttr.Value = package.Id;
var versionAttr = powerShellXmlConfig.CreateAttribute("version");
versionAttr.Value = package.Version;
packageNode.Attributes.Append(nameAttr);
packageNode.Attributes.Append(versionAttr);
projectNode.AppendChild(packageNode);
packagesPerProject[projectFilePath].Add(package);
});
}
powerShellXmlConfig.Save(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, PowershellFolderName, "config.xml"));
this.logger.LogInformation("Successfully exported powershell config!");
}
private SitecoreConfiguration GetSitecoreConfigurationFromVsTemplateFile(
XDocument document, Dictionary <string, string> replacementsDictionary)
{
// Get elements with no namespaces
var sitecoreElement = document.Root
.GetXElementWithNoNamespace("WizardData")
.GetXElementWithNoNamespace("sitecore");
var helixElement = sitecoreElement
.GetXElementWithNoNamespace("helix");
var packageElements = sitecoreElement
.GetXElementWithNoNamespace("NuGet")
.GetXElementWithNoNamespace("packages")
.GetXElementsWithNoNamespace("package");
// build Sitecore configuration
var sitecoreConfiguration = new SitecoreConfiguration()
{
IsStub = Convert.ToBoolean(sitecoreElement.Attribute("isStub")?.Value),
HelixConfiguration = new HelixConfiguration()
{
Layer = helixElement?.Attribute("layer")?.Value,
BusinessObjectiveName = helixElement?.Attribute("businessObjectiveName")?.Value,
ProvisionTestsFolder = Convert.ToBoolean(helixElement?.Attribute("provisionTestsFolder")?.Value),
ProvisionEngineFolder = Convert.ToBoolean(helixElement?.Attribute("provisionEngineFolder")?.Value),
ProvisionSerializationFolder = Convert.ToBoolean(helixElement?.Attribute("provisionSerializationFolder")?.Value)
},
NuGetConfiguration = new NuGetConfiguration()
};
// infer business objective name if nothing is specified
if (string.IsNullOrWhiteSpace(sitecoreConfiguration.HelixConfiguration.BusinessObjectiveName))
{
var projectNameParts = replacementsDictionary["$safeprojectname$"]?
.Replace(".stub", "")
.Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
sitecoreConfiguration.HelixConfiguration.BusinessObjectiveName = projectNameParts.Last();
}
if (packageElements != null)
{
foreach (var packageElement in packageElements)
{
var package = new NuGetPackage()
{
Name = packageElement?.Attribute("name")?.Value,
Version = packageElement?.Attribute("version")?.Value,
IgnoreDependencies = Convert.ToBoolean(packageElement?.Attribute("ignoreDependencies")?.Value)
};
sitecoreConfiguration.NuGetConfiguration.Packages.Add(package);
}
}
return(sitecoreConfiguration);
}
internal static RepoConfig ReadFrom(string jsonFilePath)
{
// Need to track any file that has dependencies
var obj = JObject.Parse(File.ReadAllText(jsonFilePath));
var fixedPackages = (JObject)obj["fixedPackages"];
var fixedPackagesList = ImmutableArray.CreateBuilder<NuGetPackage>();
foreach (var prop in fixedPackages.Properties())
{
if (prop.Value.Type == JTokenType.String)
{
var version = (string)prop.Value;
var nugetRef = new NuGetPackage(prop.Name, version);
fixedPackagesList.Add(nugetRef);
}
else
{
foreach (var version in ((JArray)prop.Value).Values<string>())
{
var nugetRef = new NuGetPackage(prop.Name, version);
fixedPackagesList.Add(nugetRef);
}
}
}
var toolsetPackagesProp = obj.Property("toolsetPackages");
var toolsetPackages = ((JArray)toolsetPackagesProp.Value).Values<string>();
GenerateData? msbuildGenerateData = null;
var generateObj = (JObject)obj.Property("generate").Value;
if (generateObj != null)
{
msbuildGenerateData = ReadGenerateData(generateObj, "msbuild");
}
var nuspecExcludes = new List<Regex>();
var nuspecExcludesProp = obj.Property("nuspecExcludes");
if (nuspecExcludesProp != null)
{
nuspecExcludes.AddRange(((JArray)nuspecExcludesProp.Value).Values<string>().Select(x => new Regex(x)));
}
var projectJsonExcludes = new List<Regex>();
var projectJsonExcludesProp = obj.Property("projectJsonExcludes");
if (projectJsonExcludesProp != null)
{
projectJsonExcludes.AddRange(((JArray)projectJsonExcludesProp.Value).Values<string>().Select(x => new Regex(x)));
}
return new RepoConfig(
fixedPackagesList,
toolsetPackages,
nuspecExcludes,
projectJsonExcludes,
msbuildGenerateData);
}
public PageItemViewModel(NuGetPackage package, IModelProvider <ExplorerSettingsContainer> settingsProvider)
{
Argument.IsNotNull(() => package);
Argument.IsNotNull(() => settingsProvider);
Package = package;
_nugetSettings = settingsProvider.Model;
//command
CheckItem = new Command <MouseButtonEventArgs>(CheckItemExecute);
}
private static PackageArchiveReader GetArchiveReader(this NuGetPackage pkg, FolderNuGetProject project)
{
var pkgPath = pkg.GetPackageFilePath(project)?.FullPath;
if (pkgPath == null)
{
return(null);
}
return(new PackageArchiveReader(pkgPath, null, null));
}
public void DeletePackage_HappyPath(HttpStatusCode statusCode)
{
_mockHttp.Expect(HttpMethod.Delete, "https://www.nuget.org/api/v2/package/L10NSharp/4.0.3-beta0003")
.WithHeaders("X-NuGet-ApiKey", "apikey12345").Respond(statusCode);
NuGetPackage.HttpClient = _mockHttp.ToHttpClient();
var sut = new NuGetPackage("L10NSharp", "apikey12345");
Assert.That(async() => await sut.DeletePackage(SemanticVersion.Parse("4.0.3-beta0003")),
Throws.Nothing);
}
/// <summary>
/// Gets vulnerabilities for a single NuGet Package.
/// </summary>
/// <param name="pkg">NuGetPackage to check</param>
/// <returns></returns>
private static async Task <ComponentReport> GetReportForPackageAsync(NuGetPackage pkg)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(ResponseContentType));
var response = await client.GetStringAsync($"https://ossindex.sonatype.org/api/v3/component-report/{pkg.PackageUrl}");
return(JsonSerializer.Deserialize <ComponentReport>(response, new JsonSerializerOptions()));
}
}
public VisualStudioUIContext(
NuGetPackage package,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_package = package;
}
public INuGetUIContext Create(NuGetPackage package, IEnumerable<NuGet.ProjectManagement.NuGetProject> projects)
{
if (projects == null || !projects.Any())
{
throw new ArgumentNullException("projects");
}
NuGetPackageManager packageManager = new NuGetPackageManager(_repositoryProvider, _settings, _solutionManager);
UIActionEngine actionEngine = new UIActionEngine(_repositoryProvider, packageManager);
return new VisualStudioUIContext(
package,
_repositoryProvider,
_solutionManager,
packageManager,
actionEngine,
_restoreManager,
_optionsPage,
projects);
}
private static bool TryParsePackage(TextWriter writer, string packageLine, List<NuGetPackage> changes)
{
var match = Regex.Match(packageLine, @"([^\s]*)\s*(.*)");
if (match.Success)
{
var package = new NuGetPackage(
match.Groups[1].Value,
match.Groups[2].Value);
changes.Add(package);
return true;
}
match = Regex.Match(packageLine, @"([^\s]*)\s*-\s*(.*)");
if (match.Success)
{
var package = new NuGetPackage(
match.Groups[1].Value,
match.Groups[2].Value);
changes.Add(package);
return true;
}
writer.WriteLine($"Unable to parse package {packageLine}");
return false;
}
internal NuGetPackageSource(NuGetPackage package, FileName fileName)
{
NuGetPackage = package;
FileName = fileName;
}
private static void AddNuGetDependency(JObject projectJson, NuGetPackage nugetPackage,
FrameworkName targetFramework)
{
var frameworksObj = GetOrAddJObject(projectJson, "frameworks");
var targetFrameworkObj = GetOrAddJObject(frameworksObj, GetShortFrameworkName(targetFramework));
var dependenciesObj = GetOrAddJObject(targetFrameworkObj, "dependencies");
dependenciesObj[nugetPackage.Identity] = nugetPackage.Version;
}
private static JProperty GetProperty(NuGetPackage package)
{
return new JProperty(package.Name, package.Version);
}
private static string GetKey(NuGetPackage nugetRef)
{
return $"{nugetRef.Name}:{nugetRef.Version}";
}
