public PackageViewModel(Package package)
{
_package = package;
Version = String.IsNullOrEmpty(package.NormalizedVersion) ?
SemanticVersionExtensions.Normalize(package.Version) :
package.NormalizedVersion;
Description = package.Description;
ReleaseNotes = package.ReleaseNotes;
IconUrl = package.IconUrl;
ProjectUrl = package.ProjectUrl;
LicenseUrl = package.LicenseUrl;
HideLicenseReport = package.HideLicenseReport;
LatestVersion = package.IsLatest;
LatestStableVersion = package.IsLatestStable;
LastUpdated = package.Published;
Listed = package.Listed;
DownloadCount = package.DownloadCount;
Prerelease = package.IsPrerelease;
LicenseReportUrl = package.LicenseReportUrl;
var licenseNames = package.LicenseNames;
if (!String.IsNullOrEmpty(licenseNames))
{
LicenseNames = licenseNames.Split(',').Select(l => l.Trim());
}
}
public ManagePackageOwnersViewModel(Package package, IPrincipal currentUser)
: base(package)
{
CurrentOwnerUsername = currentUser.Identity.Name;
OtherOwners = Owners.Where(o => o.Username != CurrentOwnerUsername);
OtherOwners = new[] { new User { Username = "******" } };
}
public void UpdatePackage(Package package)
{
var packageRegistrationKey = package.PackageRegistrationKey;
var updateTerm = new Term("PackageRegistrationKey", packageRegistrationKey.ToString(CultureInfo.InvariantCulture));
if (!package.IsLatest || package.IsLatestStable)
{
// Someone passed us in a version which was e.g. just unlisted? Or just not the latest version which is what we want to index. Doesn't really matter. We'll find one to index.
package = _packageRepository.GetAll()
.Where(p => (p.IsLatest || p.IsLatestStable) && p.PackageRegistrationKey == packageRegistrationKey)
.Include(p => p.PackageRegistration)
.Include(p => p.PackageRegistration.Owners)
.Include(p => p.SupportedFrameworks)
.FirstOrDefault();
}
// Just update the provided package
using (Trace.Activity(String.Format(CultureInfo.CurrentCulture, "Updating Lucene Index for: {0} {1} [PackageKey:{2}]", package.PackageRegistration.Id, package.Version, package.Key)))
{
EnsureIndexWriter(creatingIndex: false);
if (package != null)
{
var indexEntity = new PackageIndexEntity(package);
Trace.Information(String.Format(CultureInfo.CurrentCulture, "Updating Document: {0}", updateTerm.ToString()));
_indexWriter.UpdateDocument(updateTerm, indexEntity.ToDocument());
}
else
{
Trace.Information(String.Format(CultureInfo.CurrentCulture, "Deleting Document: {0}", updateTerm.ToString()));
_indexWriter.DeleteDocuments(updateTerm);
}
_indexWriter.Commit();
}
}
public EditPackageVersionRequest(Package package, PackageEdit pendingMetadata)
{
var metadata = pendingMetadata ?? new PackageEdit
{
Authors = package.FlattenedAuthors,
Copyright = package.Copyright,
Description = package.Description,
IconUrl = package.IconUrl,
LicenseUrl = package.LicenseUrl,
ProjectUrl = package.ProjectUrl,
ReleaseNotes = package.ReleaseNotes,
RequiresLicenseAcceptance = package.RequiresLicenseAcceptance,
Summary = package.Summary,
Tags = package.Tags,
Title = package.Title,
};
Authors = metadata.Authors;
Copyright = metadata.Copyright;
Description = metadata.Description;
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
ReleaseNotes = metadata.ReleaseNotes;
RequiresLicenseAcceptance = metadata.RequiresLicenseAcceptance;
Summary = metadata.Summary;
Tags = metadata.Tags;
VersionTitle = metadata.Title;
}
public PackageViewModel(Package package)
{
this.package = package;
Version = package.Version;
Description = package.Description;
ReleaseNotes = package.ReleaseNotes;
IconUrl = package.IconUrl;
ProjectUrl = package.ProjectUrl;
ProjectSourceUrl = package.ProjectSourceUrl;
PackageSourceUrl = package.PackageSourceUrl;
DocsUrl = package.DocsUrl;
MailingListUrl = package.MailingListUrl;
BugTrackerUrl = package.BugTrackerUrl;
LicenseUrl = package.LicenseUrl;
LatestVersion = package.IsLatest;
LatestStableVersion = package.IsLatestStable;
LastUpdated = package.Status == PackageStatusType.Submitted ? package.LastUpdated : package.Published;
PublishedDate = package.Published;
Listed = package.Listed;
DownloadCount = package.DownloadCount;
Prerelease = package.IsPrerelease;
Status = package.Status;
SubmittedStatus = package.SubmittedStatus;
ApprovedDate = package.ApprovedDate;
ReviewerUserName = package.ReviewedBy != null ? package.ReviewedBy.Username : string.Empty;
ReviewerEmailAddress = package.ReviewedBy != null ? package.ReviewedBy.EmailAddress : string.Empty;
ReviewedDate = package.ReviewedDate;
ReviewComments = package.ReviewComments;
}
public async Task CreateNuGetExeDownloadExtractsFileIfItDoesNotExist()
{
// Arrange
var fileStorage = new Mock<IFileStorageService>(MockBehavior.Strict);
fileStorage.Setup(s => s.FileExistsAsync("downloads", "nuget.exe")).Returns(Task.FromResult(false));
fileStorage.Setup(s => s.SaveFileAsync("downloads", "nuget.exe", It.IsAny<Stream>()))
.Returns(Task.FromResult(0))
.Verifiable();
fileStorage.Setup(s => s.CreateDownloadFileActionResultAsync("downloads", "nuget.exe"))
.Returns(Task.FromResult(Mock.Of<ActionResult>()))
.Verifiable();
var package = new Package { Version = "2.0.0" };
var packageService = new Mock<IPackageService>(MockBehavior.Strict);
packageService.Setup(s => s.FindPackageByIdAndVersion("NuGet.CommandLine", null, false))
.Returns(package)
.Verifiable();
var packageFileService = new Mock<IPackageFileService>(MockBehavior.Strict);
packageFileService.Setup(s => s.DownloadPackageFileAsync(package))
.Returns(Task.FromResult(CreateCommandLinePackage()))
.Verifiable();
// Act
var downloaderService = GetDownloaderService(packageService, packageFileService, fileStorage);
await downloaderService.CreateNuGetExeDownloadActionResultAsync();
// Assert
packageFileService.Verify();
packageService.Verify();
}
public DisplayPackageViewModel(Package package, IOrderedEnumerable<Package> packageHistory, bool isVersionHistory)
: base(package)
{
Copyright = package.Copyright;
if (!isVersionHistory)
{
Dependencies = new DependencySetsViewModel(package.Dependencies);
PackageVersions = packageHistory.Select(p => new DisplayPackageViewModel(p, packageHistory, isVersionHistory: true));
}
DownloadCount = package.DownloadCount;
LastEdited = package.LastEdited;
if (!isVersionHistory && packageHistory.Any())
{
// calculate the number of days since the package registration was created
// round to the nearest integer, with a min value of 1
// divide the total download count by this number
TotalDaysSinceCreated = Convert.ToInt32(Math.Max(1, Math.Round((DateTime.UtcNow - packageHistory.Last().Created).TotalDays)));
DownloadsPerDay = TotalDownloadCount / TotalDaysSinceCreated; // for the package
}
else
{
TotalDaysSinceCreated = 0;
DownloadsPerDay = 0;
}
}
public void ContactSiteAdmins(MailAddress fromAddress, Package package, string message,string packageUrl, bool copySender)
{
string subject = "[{0}] Contact Site Admins for Package '{1}' Version '{2}'";
string body = @"_User {0} ({1}) is reporting on '{2}' version '{3}'.
{0} left the following information in the report:_
{4}
_Message sent from {5}_
Current Maintainer(s): {7}
Package Url: {6}
";
body = String.Format(CultureInfo.CurrentCulture,
body,
fromAddress.DisplayName,
fromAddress.Address,
package.PackageRegistration.Id,
package.Version,
message,
settings.GalleryOwnerName,
packageUrl,
string.Join(", ",package.PackageRegistration.Owners.Select(x => x.Username)));
using (var mailMessage = new MailMessage())
{
mailMessage.Subject = String.Format(CultureInfo.CurrentCulture, subject, settings.GalleryOwnerName, package.PackageRegistration.Id, package.Version);
mailMessage.Body = body;
mailMessage.From = fromAddress;
mailMessage.To.Add(settings.GalleryOwnerEmail);
SendMessage(mailMessage,copySender);
}
}
public async Task CreatePackageWillSavePackageFileToFileStorage()
{
// Arrange
var user = new User() { EmailAddress = "*****@*****.**" };
var packageRegistration = new PackageRegistration();
packageRegistration.Id = "theId";
packageRegistration.Owners.Add(user);
var package = new Package();
package.PackageRegistration = packageRegistration;
package.Version = "1.0.42";
packageRegistration.Packages.Add(package);
var controller = new TestableApiController();
controller.SetCurrentUser(user);
controller.MockPackageFileService.Setup(p => p.SavePackageFileAsync(It.IsAny<Package>(), It.IsAny<Stream>()))
.Returns(Task.CompletedTask).Verifiable();
controller.MockPackageService.Setup(p => p.FindPackageRegistrationById(It.IsAny<string>()))
.Returns(packageRegistration);
controller.MockPackageService.Setup(p => p.CreatePackageAsync(It.IsAny<PackageArchiveReader>(), It.IsAny<PackageStreamMetadata>(), It.IsAny<User>(), false))
.Returns(Task.FromResult(package));
var nuGetPackage = TestPackage.CreateTestPackageStream("theId", "1.0.42");
controller.SetupPackageFromInputStream(nuGetPackage);
// Act
await controller.CreatePackagePut();
// Assert
controller.MockPackageFileService.Verify();
}
public MailMessage ReportAbuse(MailAddress fromAddress, Package package, string message)
{
string subject = "[{0}] Abuse Report for Package '{1}' Version '{2}'";
string body = @"_User {0} ({1}) reports the package '{2}' version '{3}' as abusive.
{0} left the following information in the report:_
{4}
_Message sent from {5}_
";
body = String.Format(body,
fromAddress.DisplayName,
fromAddress.Address,
package.PackageRegistration.Id,
package.Version,
message,
settings.GalleryOwnerName);
using (
var mailMessage = new MailMessage
{
Subject = String.Format(subject, settings.GalleryOwnerName, package.PackageRegistration.Id, package.Version),
Body = body,
From = fromAddress,
})
{
mailMessage.To.Add(settings.GalleryOwnerEmail);
SendMessage(mailMessage);
return mailMessage;
}
}
public void IdConflictsWithExistingPackageTitleTests(string existingPackageId, string existingPackageTitle, string newPackageId, bool shouldBeConflict)
{
// Arrange
var existingPackageRegistration = new PackageRegistration
{
Id = existingPackageId,
Owners = new HashSet<User>()
};
var existingPackage = new Package
{
PackageRegistration = existingPackageRegistration,
Version = "1.0.0",
Title = existingPackageTitle
};
var packageRegistrationRepository = new Mock<IEntityRepository<PackageRegistration>>();
packageRegistrationRepository.Setup(r => r.GetAll()).Returns(new[] { existingPackageRegistration }.AsQueryable());
var packageRepository = new Mock<IEntityRepository<Package>>();
packageRepository.Setup(r => r.GetAll()).Returns(new[] { existingPackage }.AsQueryable());
var target = new PackageNamingConflictValidator(packageRegistrationRepository.Object, packageRepository.Object);
// Act
var result = target.IdConflictsWithExistingPackageTitle(newPackageId);
// Assert
Assert.True(result == shouldBeConflict);
}
public override void Curate(
Package galleryPackage,
IPackage nugetPackage)
{
var curatedFeed = GetService<ICuratedFeedByNameQuery>().Execute("webmatrix");
if (curatedFeed == null)
return;
if (!galleryPackage.IsLatestStable)
return;
var shouldBeIncluded = galleryPackage.Tags != null && galleryPackage.Tags.ToLowerInvariant().Contains("aspnetwebpages");
if (!shouldBeIncluded)
{
shouldBeIncluded = true;
foreach (var file in nugetPackage.GetFiles())
{
var fi = new FileInfo(file.Path);
if (fi.Extension == ".ps1" || fi.Extension == ".t4")
{
shouldBeIncluded = false;
break;
}
}
}
if (shouldBeIncluded)
GetService<ICreateCuratedPackageCommand>().Execute(
curatedFeed.Key,
galleryPackage.PackageRegistration.Key,
automaticallyCurated: true);
}
public void WillCopySenderIfAsked()
{
var from = new MailAddress("*****@*****.**", "too");
var package = new Package
{
PackageRegistration = new PackageRegistration { Id = "smangit" },
Version = "1.42.0.1",
};
var messageService = new TestableMessageService();
var reportPackageRequest = new ReportPackageRequest
{
AlreadyContactedOwners = true,
FromAddress = from,
Message = "Abuse!",
Package = package,
Reason = "Reason!",
RequestingUser = new User
{
Username = "******",
EmailAddress = "*****@*****.**"
},
Url = TestUtility.MockUrlHelper(),
CopySender = true,
};
messageService.ReportAbuse(reportPackageRequest);
var message = messageService.MockMailSender.Sent.Single();
Assert.Equal(TestGalleryOwner, message.To.Single());
Assert.Equal(TestGalleryOwner, message.From);
Assert.Equal(reportPackageRequest.FromAddress, message.ReplyToList.Single());
Assert.Equal(reportPackageRequest.FromAddress, message.CC.Single());
Assert.DoesNotContain("Owners", message.Body);
}
public async Task ExecuteAsync(Package galleryPackage, PackageArchiveReader nugetPackage, bool commitChanges)
{
foreach (var curator in _curators)
{
await curator.CurateAsync(galleryPackage, nugetPackage, commitChanges: commitChanges);
}
}
public void ReportAbuse(MailAddress fromAddress, Package package, string message)
{
const string subject = "[{0}] Abuse Report for Package '{1}' Version '{2}'";
string body = @"_User {0} ({1}) reports the package '{2}' version '{3}' as abusive.
{0} left the following information in the report:_
{4}
_Message sent from {5}_
";
body = String.Format(
CultureInfo.CurrentCulture,
body,
fromAddress.DisplayName,
fromAddress.Address,
package.PackageRegistration.Id,
package.Version,
message,
_settings.GalleryOwnerName);
using (var mailMessage = new MailMessage())
{
mailMessage.Subject = String.Format(
CultureInfo.CurrentCulture, subject, _settings.GalleryOwnerName, package.PackageRegistration.Id, package.Version);
mailMessage.Body = body;
mailMessage.From = fromAddress;
mailMessage.To.Add(_settings.GalleryOwnerEmail);
SendMessage(mailMessage);
}
}
internal static bool ShouldCuratePackage(
CuratedFeed curatedFeed,
Package galleryPackage,
INupkg nugetPackage)
{
if (!galleryPackage.IsLatestStable)
{
return false;
}
bool shouldBeIncluded = galleryPackage.Tags != null &&
galleryPackage.Tags.ToLowerInvariant().Contains("aspnetwebpages");
if (!shouldBeIncluded)
{
shouldBeIncluded = true;
foreach (var filePath in nugetPackage.GetFiles())
{
var fi = new FileInfo(filePath);
if (fi.Extension == ".ps1" || fi.Extension == ".t4")
{
return false;
}
}
}
if (!shouldBeIncluded)
{
return false;
}
return DependenciesAreCurated(galleryPackage, curatedFeed);
}
public void Execute(Package galleryPackage, IPackage nugetPackage, bool commitChanges)
{
foreach (var curator in GetServices<IAutomaticPackageCurator>())
{
curator.Curate(galleryPackage, nugetPackage, commitChanges: commitChanges);
}
}
public override async Task CurateAsync(Package galleryPackage, PackageArchiveReader nugetPackage, bool commitChanges)
{
// Make sure the target feed exists
CuratedFeed feed = CuratedFeedService.GetFeedByName(CuratedFeedName, includePackages: true);
if (feed != null && galleryPackage.Tags != null)
{
// Break the tags up so we can be sure we don't catch any partial matches (i.e. "foobar" when we're looking for "foo")
string[] tags = galleryPackage.Tags.Split();
// Check if this package should be curated
if (tags.Any(tag => RequiredTags.Contains(tag, StringComparer.OrdinalIgnoreCase)))
{
// It should!
// But now we need to ensure that the package's dependencies are also curated
if (DependenciesAreCurated(galleryPackage, feed))
{
await CuratedFeedService.CreatedCuratedPackageAsync(
feed,
galleryPackage.PackageRegistration,
automaticallyCurated: true,
commitChanges: commitChanges);
}
}
}
}
internal static bool ShouldCuratePackage(
CuratedFeed curatedFeed,
Package galleryPackage,
INupkg nugetPackage)
{
return
// Must have min client version of null or <= 2.2
(nugetPackage.Metadata.MinClientVersion == null || nugetPackage.Metadata.MinClientVersion <= new Version(2, 2)) &&
// Must be latest stable
galleryPackage.IsLatestStable &&
// Must support net40
SupportsNet40(galleryPackage) &&
// Dependencies on the gallery must be curated
DependenciesAreCurated(galleryPackage, curatedFeed) &&
(
// Must have AspNetWebPages tag
ContainsAspNetWebPagesTag(galleryPackage) ||
// OR: Must not contain powershell or T4
DoesNotContainUnsupportedFiles(nugetPackage)
);
}
/// <summary>
/// Returns the newest, uncompleted metadata for a package (i.e. a pending edit)
/// </summary>
public virtual PackageEdit GetPendingMetadata(Package p)
{
return EntitiesContext.Set<PackageEdit>()
.Where(m => m.PackageKey == p.Key)
.OrderByDescending(m => m.Timestamp)
.FirstOrDefault();
}
public void Execute(Package galleryPackage, PackageReader nugetPackage, bool commitChanges)
{
foreach (var curator in _curators)
{
curator.Curate(galleryPackage, nugetPackage, commitChanges: commitChanges);
}
}
public virtual void StartEditPackageRequest(Package p, EditPackageVersionRequest request, User editingUser)
{
PackageEdit edit = new PackageEdit
{
// Description
User = editingUser,
Authors = request.Authors,
Copyright = request.Copyright,
Description = request.Description,
IconUrl = request.IconUrl,
LicenseUrl = p.LicenseUrl, // Our current policy is not to allow editing the license URL, so just clone it from its previous value.
ProjectUrl = request.ProjectUrl,
ReleaseNotes = request.ReleaseNotes,
RequiresLicenseAcceptance = request.RequiresLicenseAcceptance,
Summary = request.Summary,
Tags = request.Tags,
Title = request.VersionTitle,
// Other
Package = p,
Timestamp = DateTime.UtcNow,
TriedCount = 0,
};
EntitiesContext.Set<PackageEdit>().Add(edit);
// Note: EditPackageRequests are completed asynchronously by the worker role.
}
public ListPackageItemViewModel(Package package)
: base(package)
{
Tags = package.Tags != null ? package.Tags.Trim().Split(' ') : null;
Authors = package.Authors;
Owners = package.PackageRegistration.Owners;
}
public PackageIndexEntity(Package package, int curatedFeedKey, bool isLatest, bool isLatestStable)
{
this.Package = package;
this.curatedFeedKey = curatedFeedKey;
this.isLatest = isLatest;
this.isLatestStable = isLatestStable;
}
internal static bool ShouldCuratePackage(
CuratedFeed curatedFeed,
Package galleryPackage,
PackageArchiveReader packageArchiveReader)
{
var nuspec = packageArchiveReader.GetNuspecReader();
return
// Must have min client version of null or <= 2.2
(nuspec.GetMinClientVersion() == null || nuspec.GetMinClientVersion() <= new NuGetVersion(2, 2, 0)) &&
// Must be latest stable
galleryPackage.IsLatestStable &&
// Must support net40
SupportsNet40(galleryPackage) &&
(
// Must have AspNetWebPages tag
ContainsAspNetWebPagesTag(galleryPackage) ||
// OR: Must not contain powershell or T4
DoesNotContainUnsupportedFiles(packageArchiveReader)
) &&
// Dependencies on the gallery must be curated
DependenciesAreCurated(galleryPackage, curatedFeed);
}
public Stream DownloadPackageFile(Package package)
{
var fileName = BuildFileName(package);
return fileStorageSvc.GetFile(
Constants.PackagesFolderName,
fileName);
}
public ActionResult CreateDownloadPackageActionResult(Package package)
{
var fileName = BuildFileName(package);
return fileStorageSvc.CreateDownloadFileActionResult(
Constants.PackagesFolderName,
fileName);
}
private void ClearSupportedFrameworks(Package package)
{
foreach (var supportedFramework in package.SupportedFrameworks.ToList())
{
_entitiesContext.Set<PackageFramework>().Remove(supportedFramework);
}
package.SupportedFrameworks.Clear();
}
public ListPackageItemViewModel(Package package)
: base(package)
{
Tags = package.Tags != null ? package.Tags.Trim().Split(' ') : null;
Authors = package.FlattenedAuthors;
MinClientVersion = package.MinClientVersion;
Owners = package.PackageRegistration.Owners;
}
public DeletePackageViewModel(Package package, ReportPackageReason[] reportOtherPackageReasons)
: base(package)
{
DeletePackagesRequest = new DeletePackagesRequest
{
Packages = new List<string> { string.Format(CultureInfo.InvariantCulture, "{0}|{1}", package.PackageRegistration.Id, package.Version) },
ReasonChoices = reportOtherPackageReasons
};
}
private static bool ContainsAspNetWebPagesTag(Package galleryPackage)
{
return(galleryPackage.Tags != null &&
galleryPackage.Tags.ToLowerInvariant().Contains("aspnetwebpages"));
}
