protected Facts()
{
_package = new Package();
_curatedFeed = new CuratedFeed
{
Name = "curated-feed",
Packages = new[]
{
new CuratedPackage
{
PackageRegistration = new PackageRegistration
{
Packages = new[]
{
_package,
},
},
},
},
};
_entityRepository = new Mock <IEntityRepository <CuratedFeed> >();
_config = new Mock <IAppConfiguration>();
_entityRepository
.Setup(x => x.GetAll())
.Returns(() => new[] { _curatedFeed }.AsQueryable());
_target = new CuratedFeedService(
_entityRepository.Object,
_config.Object);
}
public virtual async Task <ActionResult> DeleteCuratedPackage(
string curatedFeedName,
string curatedPackageId)
{
var curatedFeed = CuratedFeedService.GetFeedByName(curatedFeedName, includePackages: true);
if (curatedFeed == null)
{
return(HttpNotFound());
}
var curatedPackage = curatedFeed.Packages.SingleOrDefault(cp => cp.PackageRegistration.Id == curatedPackageId);
if (curatedPackage == null)
{
return(HttpNotFound());
}
if (curatedFeed.Managers.All(manager => manager.Username != User.Identity.Name))
{
return(new HttpStatusCodeResult(403));
}
await CuratedFeedService.DeleteCuratedPackageAsync(
curatedFeed.Key,
curatedPackage.Key);
return(new HttpStatusCodeResult(204));
}
protected virtual void UpdateAccountViewModel(TUser account, TAccountViewModel model)
{
model.Account = account;
model.AccountName = account.Username;
var currentUser = GetCurrentUser();
model.CanManage = ActionsRequiringPermissions.ManageAccount.CheckPermissions(
currentUser, account) == PermissionsCheckResult.Allowed;
model.IsCertificatesUIEnabled = ContentObjectService.CertificatesConfiguration?.IsUIEnabledForUser(currentUser) ?? false;
model.WasMultiFactorAuthenticated = User.WasMultiFactorAuthenticated();
model.CuratedFeeds = CuratedFeedService
.GetFeedsForManager(account.Key)
.Select(f => f.Name)
.ToList();
model.HasPassword = account.Credentials.Any(c => c.IsPassword());
model.CurrentEmailAddress = account.UnconfirmedEmailAddress ?? account.EmailAddress;
model.HasConfirmedEmailAddress = !string.IsNullOrEmpty(account.EmailAddress);
model.HasUnconfirmedEmailAddress = !string.IsNullOrEmpty(account.UnconfirmedEmailAddress);
model.ChangeEmail = new ChangeEmailViewModel();
model.ChangeNotifications = model.ChangeNotifications ?? new ChangeNotificationsViewModel();
model.ChangeNotifications.EmailAllowed = account.EmailAllowed;
model.ChangeNotifications.NotifyPackagePushed = account.NotifyPackagePushed;
}
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);
}
}
}
}
public override async Task CurateAsync(
Package galleryPackage,
PackageArchiveReader nugetPackage,
bool commitChanges)
{
var shouldBeIncluded = ShouldCuratePackage(galleryPackage, nugetPackage);
if (!shouldBeIncluded)
{
return;
}
var curatedFeed = CuratedFeedService.GetFeedByName("webmatrix", includePackages: true);
if (curatedFeed == null)
{
return;
}
if (DependenciesAreCurated(galleryPackage, curatedFeed))
{
await CuratedFeedService.CreatedCuratedPackageAsync(
curatedFeed,
galleryPackage.PackageRegistration,
included : true,
automaticallyCurated : true,
commitChanges : commitChanges);
}
}
public virtual ActionResult PostCuratedPackages(
string curatedFeedName,
CreateCuratedPackageRequest request)
{
var curatedFeed = CuratedFeedService.GetFeedByName(curatedFeedName, includePackages: true);
if (curatedFeed == null)
{
return(HttpNotFound());
}
if (curatedFeed.Managers.All(manager => manager.Username != User.Identity.Name))
{
return(new HttpStatusCodeResult(403));
}
if (!ModelState.IsValid)
{
ViewBag.CuratedFeedName = curatedFeed.Name;
return(View("CreateCuratedPackageForm"));
}
var packageRegistration = EntitiesContext.PackageRegistrations
.Where(pr => pr.Id == request.PackageId)
.Include(pr => pr.Packages)
.Include(pr => pr.Owners)
.FirstOrDefault();
if (packageRegistration == null)
{
ModelState.AddModelError("PackageId", Strings.PackageWithIdDoesNotExist);
ViewBag.CuratedFeedName = curatedFeed.Name;
return(View("CreateCuratedPackageForm"));
}
if (curatedFeed.Packages.Any(cp => cp.PackageRegistration.Key == packageRegistration.Key))
{
ModelState.AddModelError("PackageId", Strings.PackageIsAlreadyCurated);
ViewBag.CuratedFeedName = curatedFeed.Name;
return(View("CreateCuratedPackageForm"));
}
var packages = packageRegistration.Packages.ToList();
foreach (var package in packages)
{
CuratedFeedService.CreatedCuratedPackage(
curatedFeed,
package,
included: true,
automaticallyCurated: false,
notes: request.Notes,
commitChanges: false);
}
CuratedFeedService.UpdateIsLatest(packageRegistration, false);
EntitiesContext.SaveChanges();
return(RedirectToRoute(RouteName.CuratedFeed, new { name = curatedFeed.Name }));
}
private ActionResult AccountView(AccountViewModel model)
{
// Load Credential info
var user = GetCurrentUser();
var curatedFeeds = CuratedFeedService.GetFeedsForManager(user.Key);
var creds = user.Credentials.Select(c => AuthService.DescribeCredential(c)).ToList();
model.Credentials = creds;
model.CuratedFeeds = curatedFeeds.Select(f => f.Name);
return(View("Account", model));
}
public virtual ActionResult Account()
{
var user = UserService.FindByUsername(CurrentUser.Identity.Name);
var curatedFeeds = CuratedFeedService.GetFeedsForManager(user.Key);
return(View(
new AccountViewModel
{
ApiKey = user.ApiKey.ToString(),
CuratedFeeds = curatedFeeds.Select(cf => cf.Name)
}));
}
public virtual async Task <ActionResult> ListPackages(string curatedFeedName, string q, int page = 1, bool prerel = true)
{
if (page < 1)
{
page = 1;
}
q = (q ?? string.Empty).Trim();
var searchFilter = SearchAdaptor.GetSearchFilter(
q,
page,
includePrerelease: prerel,
sortOrder: null,
context: SearchFilter.UISearchContext,
semVerLevel: SemVerLevelKey.SemVerLevel2);
searchFilter.CuratedFeed = CuratedFeedService.GetFeedByName(curatedFeedName, includePackages: false);
if (searchFilter.CuratedFeed == null)
{
return(HttpNotFound());
}
SearchResults results = await SearchService.Search(searchFilter);
int totalHits = results.Hits;
if (page == 1 && !results.Data.Any())
{
// In the event the index wasn't updated, we may get an incorrect count.
totalHits = 0;
}
var viewModel = new PackageListViewModel(
results.Data,
GetCurrentUser(),
results.IndexTimestampUtc,
q,
totalHits,
page - 1,
Constants.DefaultPackageListPageSize,
Url,
curatedFeedName,
includePrerelease: prerel);
ViewBag.SearchTerm = q;
return(View("ListPackages", viewModel));
}
public virtual ActionResult ListPackages(string curatedFeedName, string q, string sortOrder = null, int page = 1, bool prerelease = false)
{
if (page < 1)
{
page = 1;
}
q = (q ?? "").Trim();
if (String.IsNullOrEmpty(sortOrder))
{
// Determine the default sort order. If no query string is specified, then the sortOrder is DownloadCount
// If we are searching for something, sort by relevance.
sortOrder = q.IsEmpty() ? Constants.PopularitySortOrder : Constants.RelevanceSortOrder;
}
var searchFilter = SearchAdaptor.GetSearchFilter(q, sortOrder, page, prerelease);
searchFilter.CuratedFeedKey = CuratedFeedService.GetKey(curatedFeedName);
if (searchFilter.CuratedFeedKey == 0)
{
return(HttpNotFound());
}
int totalHits;
IQueryable <Package> packageVersions = SearchService.Search(searchFilter, out totalHits);
if (page == 1 && !packageVersions.Any())
{
// In the event the index wasn't updated, we may get an incorrect count.
totalHits = 0;
}
var viewModel = new PackageListViewModel(
packageVersions,
q,
sortOrder,
totalHits,
page - 1,
Constants.DefaultPackageListPageSize,
Url,
prerelease);
ViewBag.SearchTerm = q;
return(View("~/Views/Packages/ListPackages.cshtml", viewModel));
}
public virtual ActionResult GetCreateCuratedPackageForm(string curatedFeedName)
{
var curatedFeed = CuratedFeedService.GetFeedByName(curatedFeedName, includePackages: false);
if (curatedFeed == null)
{
return(HttpNotFound());
}
if (curatedFeed.Managers.All(manager => manager.Username != User.Identity.Name))
{
return(new HttpStatusCodeResult(403));
}
ViewBag.CuratedFeedName = curatedFeed.Name;
return(View());
}
public virtual ActionResult Account()
{
var user = UserService.FindByUsername(Identity.Name);
var curatedFeeds = CuratedFeedService.GetFeedsForManager(user.Key);
var apiCredential = user
.Credentials
.FirstOrDefault(c => c.Type == CredentialTypes.ApiKeyV1);
return(View(
new AccountViewModel
{
ApiKey = apiCredential == null ?
user.ApiKey.ToString() :
apiCredential.Value,
IsConfirmed = user.Confirmed,
CuratedFeeds = curatedFeeds.Select(cf => cf.Name)
}));
}
public virtual ActionResult PatchCuratedPackage(
string curatedFeedName,
string curatedPackageId,
ModifyCuratedPackageRequest request)
{
var curatedFeed = CuratedFeedService.GetFeedByName(curatedFeedName, includePackages: true);
if (curatedFeed == null)
{
return(HttpNotFound());
}
var curatedPackage = curatedFeed.Packages.SingleOrDefault(cp => cp.PackageRegistration.Id == curatedPackageId);
if (curatedPackage == null)
{
return(HttpNotFound());
}
if (curatedFeed.Managers.All(manager => manager.Username != Identity.Name))
{
return(new HttpStatusCodeResult(403));
}
if (!ModelState.IsValid)
{
return(new HttpStatusCodeResult(400));
}
CuratedFeedService.ModifyCuratedPackage(
curatedFeed.Key,
curatedPackage.Key,
request.Included);
return(new HttpStatusCodeResult(204));
}
public override void Curate(
Package galleryPackage,
INupkg nugetPackage,
bool commitChanges)
{
var curatedFeed = CuratedFeedService.GetFeedByName("webmatrix", includePackages: true);
if (curatedFeed == null)
{
return;
}
var shouldBeIncluded = ShouldCuratePackage(curatedFeed, galleryPackage, nugetPackage);
if (shouldBeIncluded)
{
CuratedFeedService.CreatedCuratedPackage(
curatedFeed,
galleryPackage.PackageRegistration,
included: true,
automaticallyCurated: true,
commitChanges: commitChanges);
}
}
protected virtual void UpdateAccountViewModel(TUser account, TAccountViewModel model)
{
model.Account = account;
model.AccountName = account.Username;
model.CanManage = ActionsRequiringPermissions.ManageAccount.CheckPermissions(
GetCurrentUser(), account) == PermissionsCheckResult.Allowed;
model.CuratedFeeds = CuratedFeedService
.GetFeedsForManager(account.Key)
.Select(f => f.Name)
.ToList();
model.HasPassword = account.Credentials.Any(c => c.Type.StartsWith(CredentialTypes.Password.Prefix));
model.CurrentEmailAddress = account.UnconfirmedEmailAddress ?? account.EmailAddress;
model.HasConfirmedEmailAddress = !string.IsNullOrEmpty(account.EmailAddress);
model.HasUnconfirmedEmailAddress = !string.IsNullOrEmpty(account.UnconfirmedEmailAddress);
model.ChangeEmail = new ChangeEmailViewModel();
model.ChangeNotifications = model.ChangeNotifications ?? new ChangeNotificationsViewModel();
model.ChangeNotifications.EmailAllowed = account.EmailAllowed;
model.ChangeNotifications.NotifyPackagePushed = account.NotifyPackagePushed;
}
