public virtual async Task <ActionResult> ConfirmTransformToOrganization(string accountNameToTransform, string token) { var adminUser = GetCurrentUser(); string errorReason; var accountToTransform = UserService.FindByUsername(accountNameToTransform); if (accountToTransform == null) { errorReason = String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_OrganizationAccountDoesNotExist, accountNameToTransform); return(TransformToOrganizationFailed(errorReason)); } if (!UserService.CanTransformUserToOrganization(accountToTransform, out errorReason)) { return(TransformToOrganizationFailed(errorReason)); } if (!await UserService.TransformUserToOrganization(accountToTransform, adminUser, token)) { errorReason = Strings.TransformAccount_Failed; return(TransformToOrganizationFailed(errorReason)); } MessageService.SendOrganizationTransformRequestAcceptedNotice(accountToTransform, adminUser); TelemetryService.TrackOrganizationTransformCompleted(accountToTransform); TempData["Message"] = String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_Success, accountNameToTransform); return(Redirect(Url.ManageMyOrganization(accountNameToTransform))); }
public virtual ActionResult Profiles(string username) { var user = UserService.FindByUsername(username); if (user == null) { return(HttpNotFound()); } var packages = PackageService.FindPackagesByOwner(user, includeUnlisted: false) .OrderByDescending(p => p.PackageRegistration.DownloadCount) .Select(p => new PackageViewModel(p) { DownloadCount = p.PackageRegistration.DownloadCount, Version = null }).ToList(); var model = new UserProfileModel(user) { Packages = packages, TotalPackageDownloadCount = packages.Sum(p => p.TotalDownloadCount), }; return(View(model)); }
public virtual async Task <ActionResult> TransformToOrganization(TransformAccountViewModel transformViewModel) { var accountToTransform = GetCurrentUser(); var adminUser = UserService.FindByUsername(transformViewModel.AdminUsername); if (adminUser == null) { ModelState.AddModelError(string.Empty, String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_AdminAccountDoesNotExist, transformViewModel.AdminUsername)); return(View(transformViewModel)); } if (!UserService.CanTransformUserToOrganization(accountToTransform, adminUser, out var errorReason)) { ModelState.AddModelError(string.Empty, errorReason); return(View(transformViewModel)); } await UserService.RequestTransformToOrganizationAccount(accountToTransform, adminUser); // sign out pending organization and prompt for admin sign in OwinContext.Authentication.SignOut(); TempData[Constants.ReturnUrlMessageViewDataKey] = String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_SignInToConfirm, adminUser.Username, accountToTransform.Username); var returnUrl = Url.ConfirmTransformAccount(accountToTransform); return(Redirect(Url.LogOn(returnUrl))); }
public virtual async Task <ActionResult> Delete(DeleteAccountAsAdminViewModel model) { var user = UserService.FindByUsername(model.AccountName); if (user == null || user.IsDeleted) { return(View("DeleteUserAccountStatus", new DeleteUserAccountStatus() { AccountName = model.AccountName, Description = $"Account {model.AccountName} not found.", Success = false })); } else { var admin = GetCurrentUser(); var status = await _deleteAccountService.DeleteAccountAsync( userToBeDeleted : user, userToExecuteTheDelete : admin, signature : model.Signature, orphanPackagePolicy : model.ShouldUnlist?AccountDeletionOrphanPackagePolicy.UnlistOrphans : AccountDeletionOrphanPackagePolicy.KeepOrphans, commitAsTransaction : true); return(View("DeleteUserAccountStatus", status)); } }
public virtual async Task <ActionResult> RejectTransformToOrganization(string accountNameToTransform, string token) { var adminUser = GetCurrentUser(); string message; var accountToTransform = UserService.FindByUsername(accountNameToTransform); if (accountToTransform == null) { message = String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_OrganizationAccountDoesNotExist, accountNameToTransform); } else { if (await UserService.RejectTransformUserToOrganizationRequest(accountToTransform, adminUser, token)) { MessageService.SendOrganizationTransformRequestRejectedNotice(accountToTransform, adminUser); TelemetryService.TrackOrganizationTransformDeclined(accountToTransform); message = String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_Rejected, accountNameToTransform); } else { message = Strings.TransformAccount_FailedMissingRequestToCancel; } } TempData["Message"] = message; return(RedirectToAction(actionName: "Home", controllerName: "Pages")); }
public virtual ActionResult Confirm(string username, string token) { // We don't want Login to have us as a return URL // By having this value present in the dictionary BUT null, we don't put "returnUrl" on the Login link at all ViewData[Constants.ReturnUrlViewDataKey] = null; if (!String.Equals(username, Identity.Name, StringComparison.OrdinalIgnoreCase)) { return(View(new ConfirmationViewModel { WrongUsername = true, SuccessfulConfirmation = false, })); } var user = UserService.FindByUsername(username); if (user == null) { return(HttpNotFound()); } string existingEmail = user.EmailAddress; var model = new ConfirmationViewModel { ConfirmingNewAccount = String.IsNullOrEmpty(existingEmail), SuccessfulConfirmation = true, }; try { if (!UserService.ConfirmEmailAddress(user, token)) { model.SuccessfulConfirmation = false; } } catch (EntityException) { model.SuccessfulConfirmation = false; model.DuplicateEmailAddress = true; } // SuccessfulConfirmation is required so that the confirm Action isn't a way to spam people. // Change notice not required for new accounts. if (model.SuccessfulConfirmation && !model.ConfirmingNewAccount) { MessageService.SendEmailChangeNoticeToPreviousEmailAddress(user, existingEmail); string returnUrl = HttpContext.GetConfirmationReturnUrl(); if (!String.IsNullOrEmpty(returnUrl)) { TempData["Message"] = "You have successfully confirmed your email address!"; return(new RedirectResult(RedirectHelper.SafeRedirectUrl(Url, returnUrl))); } } return(View(model)); }
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 virtual ActionResult ConfirmationRequired() { User user = UserService.FindByUsername(User.Identity.Name); var model = new ConfirmationViewModel { ConfirmingNewAccount = !(user.Confirmed), UnconfirmedEmailAddress = user.UnconfirmedEmailAddress, }; return(View(model)); }
public virtual ActionResult Delete(string accountName) { var user = UserService.FindByUsername(accountName); if (user == null || user.IsDeleted || (user is Organization)) { return(HttpNotFound()); } return(View("DeleteUserAccount", GetDeleteAccountViewModel(user))); }
public virtual ActionResult Delete(string accountName) { var accountToDelete = UserService.FindByUsername(accountName) as TUser; if (accountToDelete == null || accountToDelete.IsDeleted) { return(HttpNotFound()); } return(View(GetDeleteAccountViewName(), GetDeleteAccountViewModel(accountToDelete))); }
public virtual async Task <ActionResult> TransformToOrganization(TransformAccountViewModel transformViewModel) { var accountToTransform = GetCurrentUser(); var adminUsername = transformViewModel.AdminUsername; if (Regex.IsMatch(adminUsername, Constants.EmailValidationRegex, RegexOptions.None, Constants.EmailValidationRegexTimeout)) { ModelState.AddModelError(string.Empty, Strings.TransformAccount_AdminNameIsEmail); return(View(transformViewModel)); } var adminUser = UserService.FindByUsername(adminUsername); if (adminUser == null) { ModelState.AddModelError(string.Empty, string.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_AdminAccountDoesNotExist, adminUsername)); return(View(transformViewModel)); } if (!UserService.CanTransformUserToOrganization(accountToTransform, adminUser, out var errorReason)) { ModelState.AddModelError(string.Empty, errorReason); return(View(transformViewModel)); } // Get the user from the previous organization migration request (if there was one) so we can notify them that their request has been cancelled. var existingTransformRequestUser = accountToTransform.OrganizationMigrationRequest?.AdminUser; await UserService.RequestTransformToOrganizationAccount(accountToTransform, adminUser); if (existingTransformRequestUser != null) { await MessageService.SendOrganizationTransformRequestCancelledNoticeAsync(accountToTransform, existingTransformRequestUser); } var returnUrl = Url.ConfirmTransformAccount(accountToTransform); var confirmUrl = Url.ConfirmTransformAccount(accountToTransform, relativeUrl: false); var rejectUrl = Url.RejectTransformAccount(accountToTransform, relativeUrl: false); await MessageService.SendOrganizationTransformRequestAsync(accountToTransform, adminUser, Url.User(accountToTransform, relativeUrl: false), confirmUrl, rejectUrl); var cancelUrl = Url.CancelTransformAccount(accountToTransform, relativeUrl: false); await MessageService.SendOrganizationTransformInitiatedNoticeAsync(accountToTransform, adminUser, cancelUrl); TelemetryService.TrackOrganizationTransformInitiated(accountToTransform); // sign out pending organization and prompt for admin sign in OwinContext.Authentication.SignOut(); TempData[Constants.ReturnUrlMessageViewDataKey] = String.Format(CultureInfo.CurrentCulture, Strings.TransformAccount_SignInToConfirm, adminUser.Username, accountToTransform.Username); return(Redirect(Url.LogOn(returnUrl))); }
public virtual ActionResult ChangeEmail() { User user = UserService.FindByUsername(User.Identity.Name); var model = new ChangeEmailRequestModel { NewEmail = String.IsNullOrEmpty(user.UnconfirmedEmailAddress) ? user.EmailAddress : user.UnconfirmedEmailAddress }; return(View(model)); }
public virtual async Task <JsonResult> GenerateApiKey(string description, string owner, string[] scopes = null, string[] subjects = null, int?expirationInDays = null) { if (string.IsNullOrWhiteSpace(description)) { Response.StatusCode = (int)HttpStatusCode.BadRequest; return(Json(Strings.ApiKeyDescriptionRequired)); } if (string.IsNullOrWhiteSpace(owner)) { Response.StatusCode = (int)HttpStatusCode.BadRequest; return(Json(Strings.ApiKeyOwnerRequired)); } // Get the owner scope User scopeOwner = UserService.FindByUsername(owner); if (scopeOwner == null) { Response.StatusCode = (int)HttpStatusCode.BadRequest; return(Json(Strings.UserNotFound)); } var resolvedScopes = BuildScopes(scopeOwner, scopes, subjects); if (!VerifyScopes(resolvedScopes)) { Response.StatusCode = (int)HttpStatusCode.BadRequest; return(Json(Strings.ApiKeyScopesNotAllowed)); } // Set expiration var expiration = TimeSpan.Zero; if (_config.ExpirationInDaysForApiKeyV1 > 0) { expiration = TimeSpan.FromDays(_config.ExpirationInDaysForApiKeyV1); if (expirationInDays.HasValue && expirationInDays.Value > 0) { expiration = TimeSpan.FromDays(Math.Min(expirationInDays.Value, _config.ExpirationInDaysForApiKeyV1)); } } var newCredentialViewModel = await GenerateApiKeyInternal(description, resolvedScopes, expiration); var emailMessage = new CredentialAddedMessage( _config, GetCurrentUser(), newCredentialViewModel.GetCredentialTypeInfo()); await MessageService.SendMessageAsync(emailMessage); return(Json(new ApiKeyViewModel(newCredentialViewModel))); }
public virtual ActionResult Edit() { var user = UserService.FindByUsername(Identity.Name); var model = new EditProfileViewModel { Username = user.Username, EmailAddress = user.EmailAddress, EmailAllowed = user.EmailAllowed, PendingNewEmailAddress = user.UnconfirmedEmailAddress }; return(View(model)); }
public virtual ActionResult Edit(EditProfileViewModel profile) { var user = UserService.FindByUsername(Identity.Name); if (user == null) { return(HttpNotFound()); } profile.EmailAddress = user.EmailAddress; profile.Username = user.Username; profile.PendingNewEmailAddress = user.UnconfirmedEmailAddress; UserService.UpdateProfile(user, profile.EmailAllowed); return(View(profile)); }
public virtual ActionResult GenerateApiKey() { // Get the user var user = UserService.FindByUsername(User.Identity.Name); // Generate an API Key var apiKey = Guid.NewGuid(); // Set the existing API Key field user.ApiKey = apiKey; // Add/Replace the API Key credential, and save to the database UserService.ReplaceCredential(user, CredentialBuilder.CreateV1ApiKey(apiKey)); return(RedirectToAction(MVC.Users.Account())); }
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 virtual ActionResult Packages() { var user = UserService.FindByUsername(Identity.Name); var packages = PackageService.FindPackagesByOwner(user, includeUnlisted: true) .Select(p => new PackageViewModel(p) { DownloadCount = p.PackageRegistration.DownloadCount, Version = null }).ToList(); var model = new ManagePackagesViewModel { Packages = packages }; return(View(model)); }
public virtual ActionResult ConfirmationRequiredPost() { User user = UserService.FindByUsername(User.Identity.Name); var confirmationUrl = Url.ConfirmationUrl( MVC.Users.Confirm(), user.Username, user.EmailConfirmationToken, protocol: Request.Url.Scheme); MessageService.SendNewAccountEmail(new MailAddress(user.UnconfirmedEmailAddress, user.Username), confirmationUrl); var model = new ConfirmationViewModel { ConfirmingNewAccount = !(user.Confirmed), UnconfirmedEmailAddress = user.UnconfirmedEmailAddress, SentEmail = true, }; return(View(model)); }
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) })); }
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); }
public virtual ActionResult Profiles(string username, int page = 1) { var currentUser = GetCurrentUser(); var user = UserService.FindByUsername(username); if (user == null || user.IsDeleted) { return(HttpNotFound()); } var packages = PackageService.FindPackagesByOwner(user, includeUnlisted: false) .OrderByDescending(p => p.PackageRegistration.DownloadCount) .Select(p => new ListPackageItemViewModel(p, currentUser) { DownloadCount = p.PackageRegistration.DownloadCount }).ToList(); var model = new UserProfileModel(user, currentUser, packages, page - 1, Constants.DefaultPackageListPageSize, Url); return(View(model)); }
public virtual async Task <ActionResult> Delete(DeleteUserAccountViewModel model) { var user = UserService.FindByUsername(model.AccountName); if (user == null || user.IsDeleted) { return(View("DeleteUserAccountStatus", new DeleteUserAccountStatus() { AccountName = model.AccountName, Description = $"Account {model.AccountName} not found.", Success = false })); } else { var admin = GetCurrentUser(); var status = await _deleteAccountService.DeleteGalleryUserAccountAsync(user, admin, model.Signature, model.ShouldUnlist, commitAsTransaction : true); return(View("DeleteUserAccountStatus", status)); } }
public virtual ActionResult Profiles(string username, int page = 1, bool showAllPackages = false) { var user = UserService.FindByUsername(username); if (user == null) { return(HttpNotFound()); } var packages = PackageService.FindPackagesByOwner(user, includeUnlisted: false) .OrderByDescending(p => p.PackageRegistration.DownloadCount) .Select(p => new PackageViewModel(p) { DownloadCount = p.PackageRegistration.DownloadCount }).ToList(); var model = new UserProfileModel(user, packages, page - 1, Constants.DefaultPackageListPageSize, Url); model.ShowAllPackages = showAllPackages; return(View(model)); }
public virtual ActionResult Delete(string accountName) { var currentUser = GetCurrentUser(); var user = UserService.FindByUsername(accountName); if (user == null || user.IsDeleted || (user is Organization)) { return(HttpNotFound("User not found.")); } var listPackageItems = _packageService .FindPackagesByAnyMatchingOwner(user, includeUnlisted: true) .Select(p => new ListPackageItemViewModel(p, currentUser)) .ToList(); var model = new DeleteUserAccountViewModel { Packages = listPackageItems, User = user, AccountName = user.Username, }; return(View("DeleteUserAccount", model)); }
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 virtual async Task <ActionResult> Delete(DeleteAccountAsAdminViewModel model) { var accountToDelete = UserService.FindByUsername(model.AccountName) as TUser; if (accountToDelete == null || accountToDelete.IsDeleted) { return(View("DeleteAccountStatus", new DeleteAccountStatus() { AccountName = model.AccountName, Description = $"Account {model.AccountName} not found.", Success = false })); } else { var admin = GetCurrentUser(); var status = await DeleteAccountService.DeleteAccountAsync( userToBeDeleted : accountToDelete, userToExecuteTheDelete : admin, orphanPackagePolicy : model.ShouldUnlist?AccountDeletionOrphanPackagePolicy.UnlistOrphans : AccountDeletionOrphanPackagePolicy.KeepOrphans); return(View("DeleteAccountStatus", status)); } }
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)); } }
protected virtual TUser GetAccount(string accountName) { return(UserService.FindByUsername(accountName) as TUser); }