public async Task DeleteReservedNamespaceAsync(string existingNamespace) { if (string.IsNullOrWhiteSpace(existingNamespace)) { throw new ArgumentException(ServicesStrings.ReservedNamespace_InvalidNamespace); } using (var strategy = new SuspendDbExecutionStrategy()) using (var transaction = EntitiesContext.GetDatabase().BeginTransaction()) { var namespaceToDelete = FindReservedNamespaceForPrefix(existingNamespace) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, ServicesStrings.ReservedNamespace_NamespaceNotFound, existingNamespace)); // Delete verified flags on corresponding packages for this prefix if // it is the only prefix matching the package registration. var packageRegistrationsToMarkUnverified = namespaceToDelete .PackageRegistrations .Where(pr => pr.ReservedNamespaces.Count() == 1) .ToList(); if (packageRegistrationsToMarkUnverified.Any()) { await PackageService.UpdatePackageVerifiedStatusAsync(packageRegistrationsToMarkUnverified, isVerified : false); } ReservedNamespaceRepository.DeleteOnCommit(namespaceToDelete); await ReservedNamespaceRepository.CommitChangesAsync(); transaction.Commit(); await AuditingService.SaveAuditRecordAsync( new ReservedNamespaceAuditRecord(namespaceToDelete, AuditedReservedNamespaceAction.UnreserveNamespace)); } }
public virtual IReadOnlyCollection <ReservedNamespace> GetReservedNamespacesForId(string id) { return((from request in ReservedNamespaceRepository.GetAll() where (request.IsPrefix && id.StartsWith(request.Value)) || (!request.IsPrefix && id.Equals(request.Value)) select request).ToList()); }
public override IReadOnlyCollection <ReservedNamespace> GetReservedNamespacesForId(string id) { return((from request in ReservedNamespaceRepository.GetAll() where (request.IsPrefix && id.StartsWith(request.Value, StringComparison.OrdinalIgnoreCase)) || (!request.IsPrefix && id.Equals(request.Value, StringComparison.OrdinalIgnoreCase)) select request).ToList()); }
public async Task AddReservedNamespaceAsync(ReservedNamespace newNamespace) { if (newNamespace == null) { throw new ArgumentNullException(nameof(newNamespace)); } ValidateNamespace(newNamespace.Value); var matchingReservedNamespaces = FindAllReservedNamespacesForPrefix(prefix: newNamespace.Value, getExactMatches: !newNamespace.IsPrefix); if (matchingReservedNamespaces.Any()) { throw new InvalidOperationException(Strings.ReservedNamespace_NamespaceNotAvailable); } // Mark the new namespace as shared if it matches any liberal namespace which is a shared // namespace. For eg: A.B.* is a shared namespace, when reserving A.B.C.* namespace, // make it a shared namespace. This ensures that all namespaces under a shared // namespace are also shared to keep the data consistent. if (!newNamespace.IsSharedNamespace && ShouldForceSharedNamespace(newNamespace.Value)) { newNamespace.IsSharedNamespace = true; } ReservedNamespaceRepository.InsertOnCommit(newNamespace); await ReservedNamespaceRepository.CommitChangesAsync(); }
public virtual IReadOnlyCollection <ReservedNamespace> FindReservedNamespacesForPrefixList(IReadOnlyCollection <string> prefixList) { return((from dbPrefix in ReservedNamespaceRepository.GetAll() join queryPrefix in prefixList on dbPrefix.Value equals queryPrefix select dbPrefix).ToList()); }
public async Task DeleteOwnerFromReservedNamespaceAsync(string prefix, string username) { if (string.IsNullOrWhiteSpace(prefix)) { throw new ArgumentException(Strings.ReservedNamespace_InvalidNamespace); } if (string.IsNullOrWhiteSpace(username)) { throw new ArgumentException(Strings.ReservedNamespace_InvalidUsername); } using (var strategy = new SuspendDbExecutionStrategy()) using (var transaction = EntitiesContext.GetDatabase().BeginTransaction()) { var namespaceToModify = FindReservedNamespaceForPrefix(prefix) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.ReservedNamespace_NamespaceNotFound, prefix)); var userToRemove = UserService.FindByUsername(username) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.ReservedNamespace_UserNotFound, username)); if (!namespaceToModify.Owners.Contains(userToRemove)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.ReservedNamespace_UserNotAnOwner, username)); } var packagesOwnedByUserMatchingPrefix = namespaceToModify .PackageRegistrations .Where(pr => pr .Owners .Any(pro => pro.Username == userToRemove.Username)) .ToList(); // Remove verified mark for package registrations if the user to be removed is the only prefix owner // for the given package registration. var packageRegistrationsToMarkUnverified = packagesOwnedByUserMatchingPrefix .Where(pr => pr.Owners.Intersect(namespaceToModify.Owners).Count() == 1) .ToList(); if (packageRegistrationsToMarkUnverified.Any()) { packageRegistrationsToMarkUnverified .ForEach(pr => namespaceToModify.PackageRegistrations.Remove(pr)); await PackageService.UpdatePackageVerifiedStatusAsync(packageRegistrationsToMarkUnverified, isVerified : false); } namespaceToModify.Owners.Remove(userToRemove); await ReservedNamespaceRepository.CommitChangesAsync(); transaction.Commit(); } }
public async Task AddOwnerToReservedNamespaceAsync(string prefix, string username) { if (string.IsNullOrWhiteSpace(prefix)) { throw new ArgumentException(Strings.ReservedNamespace_InvalidNamespace); } if (string.IsNullOrWhiteSpace(username)) { throw new ArgumentException(Strings.ReservedNamespace_InvalidUsername); } using (var strategy = new SuspendDbExecutionStrategy()) using (var transaction = EntitiesContext.GetDatabase().BeginTransaction()) { var namespaceToModify = FindReservedNamespaceForPrefix(prefix) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.ReservedNamespace_NamespaceNotFound, prefix)); var userToAdd = UserService.FindByUsername(username) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.ReservedNamespace_UserNotFound, username)); if (namespaceToModify.Owners.Contains(userToAdd)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.ReservedNamespace_UserAlreadyOwner, username)); } // Mark all packages owned by this user that start with the given namespace as verified. var allPackageRegistrationsForUser = PackageService.FindPackageRegistrationsByOwner(userToAdd); var packageRegistrationsMatchingNamespace = allPackageRegistrationsForUser .Where(pr => pr.Id.StartsWith(namespaceToModify.Value, StringComparison.OrdinalIgnoreCase)) .ToList(); if (packageRegistrationsMatchingNamespace.Any()) { packageRegistrationsMatchingNamespace .ForEach(pr => namespaceToModify.PackageRegistrations.Add(pr)); await PackageService.UpdatePackageVerifiedStatusAsync(packageRegistrationsMatchingNamespace.AsReadOnly(), isVerified : true); } namespaceToModify.Owners.Add(userToAdd); await ReservedNamespaceRepository.CommitChangesAsync(); transaction.Commit(); } }
public override IReadOnlyCollection <ReservedNamespace> FindAllReservedNamespacesForPrefix(string prefix, bool getExactMatches) { Expression <Func <ReservedNamespace, bool> > prefixMatch; if (getExactMatches) { prefixMatch = dbPrefix => dbPrefix.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase); } else { prefixMatch = dbPrefix => dbPrefix.Value.StartsWith(prefix, StringComparison.OrdinalIgnoreCase); } return(ReservedNamespaceRepository.GetAll() .Where(prefixMatch) .ToList()); }
public async Task AddReservedNamespaceAsync(ReservedNamespace newNamespace) { if (newNamespace == null) { throw new ArgumentNullException(nameof(newNamespace)); } ValidateNamespace(newNamespace.Value); var matchingReservedNamespaces = FindAllReservedNamespacesForPrefix(prefix: newNamespace.Value, getExactMatches: !newNamespace.IsPrefix); if (matchingReservedNamespaces.Any()) { throw new InvalidOperationException(Strings.ReservedNamespace_NamespaceNotAvailable); } ReservedNamespaceRepository.InsertOnCommit(newNamespace); await ReservedNamespaceRepository.CommitChangesAsync(); }
private async Task <List <PackageRegistration> > DeleteOwnerFromReservedNamespaceImplAsync(string prefix, string username, ReservedNamespace namespaceToModify, bool commitChanges = true) { var userToRemove = UserService.FindByUsername(username) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, ServicesStrings.ReservedNamespace_UserNotFound, username)); if (!namespaceToModify.Owners.Contains(userToRemove)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ServicesStrings.ReservedNamespace_UserNotAnOwner, username)); } var packagesOwnedByUserMatchingPrefix = namespaceToModify .PackageRegistrations .Where(pr => pr .Owners .Any(pro => pro.Username == userToRemove.Username)) .ToList(); namespaceToModify.Owners.Remove(userToRemove); // Remove verified mark for package registrations if the user to be removed is the only prefix owner // for the given package registration. var packageRegistrationsToMarkUnverified = packagesOwnedByUserMatchingPrefix .Where(pr => !pr.Owners.Any(o => ActionsRequiringPermissions.AddPackageToReservedNamespace.CheckPermissionsOnBehalfOfAnyAccount( o, new[] { namespaceToModify }) == PermissionsCheckResult.Allowed)) .ToList(); if (packageRegistrationsToMarkUnverified.Any()) { packageRegistrationsToMarkUnverified .ForEach(pr => namespaceToModify.PackageRegistrations.Remove(pr)); await PackageService.UpdatePackageVerifiedStatusAsync(packageRegistrationsToMarkUnverified, isVerified : false, commitChanges : false); } if (commitChanges) { await ReservedNamespaceRepository.CommitChangesAsync(); } return(packageRegistrationsToMarkUnverified); }
/// <summary> /// This method fetches the reserved namespace matching the prefix and adds the /// package registration entry to the reserved namespace, the provided package registration /// should be an entry in the database or an entity from memory to be committed. /// </summary> /// <param name="prefix">The prefix value of the reserved namespace to modify</param> /// <param name="packageRegistration">The package registration entity entry to be added.</param> /// <param name="commitChanges">Flag to commit the modifications to the database, if set to false /// the caller of this method should take care of saving changes for entities context.</param> /// <returns>Awaitable task</returns> public async Task AddPackageRegistrationToNamespaceAsync(string prefix, PackageRegistration packageRegistration, bool commitChanges = true) { if (string.IsNullOrWhiteSpace(prefix)) { throw new ArgumentException(Strings.ReservedNamespace_InvalidNamespace); } if (packageRegistration == null) { throw new ArgumentNullException(nameof(packageRegistration)); } var namespaceToModify = FindReservedNamespaceForPrefix(prefix) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.ReservedNamespace_NamespaceNotFound, prefix)); namespaceToModify.PackageRegistrations.Add(packageRegistration); if (commitChanges) { await ReservedNamespaceRepository.CommitChangesAsync(); } }
private async Task <List <PackageRegistration> > DeleteOwnerFromReservedNamespaceImplAsync(string prefix, string username, ReservedNamespace namespaceToModify) { var userToRemove = UserService.FindByUsername(username) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, Strings.ReservedNamespace_UserNotFound, username)); if (!namespaceToModify.Owners.Contains(userToRemove)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.ReservedNamespace_UserNotAnOwner, username)); } var packagesOwnedByUserMatchingPrefix = namespaceToModify .PackageRegistrations .Where(pr => pr .Owners .Any(pro => pro.Username == userToRemove.Username)) .ToList(); // Remove verified mark for package registrations if the user to be removed is the only prefix owner // for the given package registration. var packageRegistrationsToMarkUnverified = packagesOwnedByUserMatchingPrefix .Where(pr => pr.Owners.Intersect(namespaceToModify.Owners).Count() == 1) .ToList(); if (packageRegistrationsToMarkUnverified.Any()) { packageRegistrationsToMarkUnverified .ForEach(pr => namespaceToModify.PackageRegistrations.Remove(pr)); await PackageService.UpdatePackageVerifiedStatusAsync(packageRegistrationsToMarkUnverified, isVerified : false); } namespaceToModify.Owners.Remove(userToRemove); await ReservedNamespaceRepository.CommitChangesAsync(); return(packageRegistrationsToMarkUnverified); }
public override IReadOnlyCollection <ReservedNamespace> FindReservedNamespacesForPrefixList(IReadOnlyCollection <string> prefixList) { return((from dbPrefix in ReservedNamespaceRepository.GetAll() where (prefixList.Any(p => p.Equals(dbPrefix.Value, StringComparison.OrdinalIgnoreCase))) select dbPrefix).ToList()); }
public IReadOnlyCollection <ReservedNamespace> GetReservedNamespacesForId(string id) { return((from request in ReservedNamespaceRepository.GetAll() where id.StartsWith(request.Value) select request).ToList()); }
public override ReservedNamespace FindReservedNamespaceForPrefix(string prefix) { return((from request in ReservedNamespaceRepository.GetAll() where request.Value.Equals(prefix, StringComparison.OrdinalIgnoreCase) select request).FirstOrDefault()); }
public async Task AddOwnerToReservedNamespaceAsync(string prefix, string username) { if (string.IsNullOrWhiteSpace(prefix)) { throw new ArgumentException(ServicesStrings.ReservedNamespace_InvalidNamespace); } if (string.IsNullOrWhiteSpace(username)) { throw new ArgumentException(ServicesStrings.ReservedNamespace_InvalidUsername); } using (var strategy = new SuspendDbExecutionStrategy()) using (var transaction = EntitiesContext.GetDatabase().BeginTransaction()) { var namespaceToModify = FindReservedNamespaceForPrefix(prefix) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, ServicesStrings.ReservedNamespace_NamespaceNotFound, prefix)); var userToAdd = UserService.FindByUsername(username) ?? throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, ServicesStrings.ReservedNamespace_UserNotFound, username)); if (namespaceToModify.Owners.Contains(userToAdd)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ServicesStrings.ReservedNamespace_UserAlreadyOwner, username)); } Expression <Func <PackageRegistration, bool> > predicate; if (namespaceToModify.IsPrefix) { predicate = registration => registration.Id.StartsWith(namespaceToModify.Value); } else { predicate = registration => registration.Id.Equals(namespaceToModify.Value); } // Mark all packages owned by this user that start with the given namespace as verified. var allPackageRegistrationsForUser = PackageService.FindPackageRegistrationsByOwner(userToAdd); // We need 'AsQueryable' here because FindPackageRegistrationsByOwner returns an IEnumerable // and to evaluate the predicate server side, the casting is essential. var packageRegistrationsMatchingNamespace = allPackageRegistrationsForUser .AsQueryable() .Where(predicate) .ToList(); if (packageRegistrationsMatchingNamespace.Any()) { packageRegistrationsMatchingNamespace .ForEach(pr => namespaceToModify.PackageRegistrations.Add(pr)); await PackageService.UpdatePackageVerifiedStatusAsync(packageRegistrationsMatchingNamespace.AsReadOnly(), isVerified : true); } namespaceToModify.Owners.Add(userToAdd); await ReservedNamespaceRepository.CommitChangesAsync(); transaction.Commit(); await AuditingService.SaveAuditRecordAsync( new ReservedNamespaceAuditRecord(namespaceToModify, AuditedReservedNamespaceAction.AddOwner, username, packageRegistrationsMatchingNamespace)); } }
public virtual ReservedNamespace FindReservedNamespaceForPrefix(string prefix) { return((from request in ReservedNamespaceRepository.GetAll() where request.Value.Equals(prefix) select request).FirstOrDefault()); }