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}"; }