public IEnumerable <string> Validate()
{
if (String.IsNullOrEmpty(Id))
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_RequiredMetadataMissing, "Id"));
}
else
{
if (Id.Length > PackageIdValidator.MaxPackageIdLength)
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_IdMaxLengthExceeded));
}
else if (!PackageIdValidator.IsValidPackageId(Id))
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.InvalidPackageId, Id));
}
}
if (Version == null)
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_RequiredMetadataMissing, "Version"));
}
if ((Authors == null || !Authors.Any(author => !String.IsNullOrEmpty(author))) && !PackageTypes.Contains(PackageType.SymbolsPackage))
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_RequiredMetadataMissing, "Authors"));
}
if (String.IsNullOrEmpty(Description))
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_RequiredMetadataMissing, "Description"));
}
if (_licenseUrl == String.Empty)
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_UriCannotBeEmpty, "LicenseUrl"));
}
if (_iconUrl == String.Empty)
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_UriCannotBeEmpty, "IconUrl"));
}
if (_projectUrl == String.Empty)
{
yield return(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_UriCannotBeEmpty, "ProjectUrl"));
}
if (RequireLicenseAcceptance && (string.IsNullOrWhiteSpace(_licenseUrl) && LicenseMetadata == null))
{
yield return(NuGetResources.Manifest_RequireLicenseAcceptanceRequiresLicenseUrl);
}
if (_licenseUrl != null && LicenseMetadata != null && (string.IsNullOrWhiteSpace(_licenseUrl) || !LicenseUrl.Equals(LicenseMetadata.LicenseUrl)))
{
yield return(NuGetResources.Manifest_LicenseUrlCannotBeUsedWithLicenseMetadata);
}
}
private static void ValidateDependencies(SemanticVersion version,
IEnumerable <PackageDependencyGroup> dependencies)
{
if (version == null)
{
// We have independent validation for null-versions.
return;
}
foreach (var dep in dependencies.SelectMany(s => s.Packages))
{
PackageIdValidator.ValidatePackageId(dep.Id);
}
}
public void Save(Stream stream)
{
// Make sure we're saving a valid package id
PackageIdValidator.ValidatePackageId(Id);
// Throw if the package doesn't contain any dependencies nor content
if (!Files.Any() && !DependencyGroups.SelectMany(d => d.Packages).Any() && !FrameworkReferences.Any())
{
throw new InvalidOperationException(NuGetResources.CannotCreateEmptyPackage);
}
if (!ValidateSpecialVersionLength(Version))
{
throw new InvalidOperationException(NuGetResources.SemVerSpecialVersionTooLong);
}
if (Version != null && Version.IsSemVer2)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.SemVer2VersionsNotSupported, Version));
}
ValidateDependencyGroups(Version, DependencyGroups);
ValidateReferenceAssemblies(Files, PackageAssemblyReferences);
using (var package = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
string psmdcpPath = $"package/services/metadata/core-properties/{Guid.NewGuid().ToString("N")}.psmdcp";
// Validate and write the manifest
WriteManifest(package, DetermineMinimumSchemaVersion(Files, DependencyGroups), psmdcpPath);
// Write the files to the package
var extensions = WriteFiles(package);
extensions.Add("nuspec");
WriteOpcContentTypes(package, extensions);
WriteOpcPackageProperties(package, psmdcpPath);
}
}
private static void ValidateDependencies(SemanticVersion version,
IEnumerable <PackageDependencyGroup> dependencies)
{
var frameworksMissingPlatformVersion = new HashSet <string>(dependencies
.Select(group => group.TargetFramework)
.Where(groupFramework => groupFramework.HasPlatform && groupFramework.PlatformVersion == FrameworkConstants.EmptyVersion)
.Select(framework => framework.GetShortFolderName()));
if (frameworksMissingPlatformVersion.Any())
{
throw new PackagingException(NuGetLogCode.NU1012, String.Format(CultureInfo.CurrentCulture, Strings.MissingTargetPlatformVersionsFromDependencyGroups, string.Join(", ", frameworksMissingPlatformVersion.OrderBy(str => str))));
}
if (version == null)
{
// We have independent validation for null-versions.
return;
}
foreach (var dep in dependencies.SelectMany(s => s.Packages))
{
PackageIdValidator.ValidatePackageId(dep.Id);
}
}
public void Save(Stream stream)
{
// Make sure we're saving a valid package id
PackageIdValidator.ValidatePackageId(Id);
// Throw if the package doesn't contain any dependencies nor content
if (!Files.Any() && !DependencyGroups.SelectMany(d => d.Packages).Any() && !FrameworkReferences.Any() && !FrameworkReferenceGroups.Any())
{
throw new PackagingException(NuGetLogCode.NU5017, NuGetResources.CannotCreateEmptyPackage);
}
ValidateDependencies(Version, DependencyGroups);
ValidateReferenceAssemblies(Files, PackageAssemblyReferences);
ValidateFrameworkAssemblies(FrameworkReferences, FrameworkReferenceGroups);
ValidateLicenseFile(Files, LicenseMetadata);
ValidateIconFile(Files, Icon);
ValidateFileFrameworks(Files);
using (var package = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
string psmdcpPath = $"package/services/metadata/core-properties/{CalcPsmdcpName()}.psmdcp";
// Validate and write the manifest
WriteManifest(package, DetermineMinimumSchemaVersion(Files, DependencyGroups), psmdcpPath);
// Write the files to the package
HashSet <string> filesWithoutExtensions = new HashSet <string>();
var extensions = WriteFiles(package, filesWithoutExtensions);
extensions.Add("nuspec");
WriteOpcContentTypes(package, extensions, filesWithoutExtensions);
WriteOpcPackageProperties(package, psmdcpPath);
}
}
public static void ValidateDependencyGroups(SemanticVersion version, IEnumerable <PackageDependencyGroup> dependencies)
{
if (version == null)
{
// We have independent validation for null-versions.
return;
}
foreach (var dep in dependencies.SelectMany(s => s.Packages))
{
PackageIdValidator.ValidatePackageId(dep.Id);
if (dep.VersionRange != null)
{
if (dep.VersionRange.HasLowerBound && dep.VersionRange.MinVersion.IsSemVer2)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.SemVer2VersionsNotSupported, dep.VersionRange.MinVersion));
}
if (dep.VersionRange.HasUpperBound && dep.VersionRange.MaxVersion.IsSemVer2)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.SemVer2VersionsNotSupported, dep.VersionRange.MaxVersion));
}
}
}
if (!version.IsPrerelease)
{
// If we are creating a production package, do not allow any of the dependencies to be a prerelease version.
var prereleaseDependency = dependencies.SelectMany(set => set.Packages).FirstOrDefault(IsPrereleaseDependency);
if (prereleaseDependency != null)
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_InvalidPrereleaseDependency, prereleaseDependency.ToString()));
}
}
}