Пример #1
0
        public async Task <DeleteAccountStatus> DeleteAccountAsync(User userToBeDeleted, User userToExecuteTheDelete, AccountDeletionOrphanPackagePolicy orphanPackagePolicy = AccountDeletionOrphanPackagePolicy.DoNotAllowOrphans)
        {
            if (userToBeDeleted == null)
            {
                throw new ArgumentNullException(nameof(userToBeDeleted));
            }

            var result = new DeleteAccountStatus()
            {
                AccountName = userToBeDeleted.Username
            };

            var isSupportRequestCreated = await _supportRequestService.TryAddDeleteSupportRequestAsync(userToBeDeleted);

            if (!isSupportRequestCreated)
            {
                result.Success     = false;
                result.Description = ServicesStrings.AccountDelete_CreateSupportRequestFails;
                return(result);
            }

            var sourceName = GalleryUserAccountDeleteMessageSourceName;

            if (userToExecuteTheDelete.IsAdministrator)
            {
                sourceName = GalleryAdminAccountDeleteMessageSourceName;
            }

            var messageData = new AccountDeleteMessage(userToBeDeleted.Username, source: sourceName);

            var message = _serializer.Serialize(messageData);

            try
            {
                await _topicClient.SendAsync(message);

                // if SendAsync doesn't throw, as far as we can tell, the message went through.
                result.Description = string.Format(CultureInfo.CurrentCulture,
                                                   ServicesStrings.AsyncAccountDelete_Success,
                                                   userToBeDeleted.Username);
                result.Success = true;
            }
            catch (Exception ex)
            {
                // See https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-messaging-exceptions for a list of possible exceptions
                _logger.LogError(0, ex, "Failed to enqueue to AccountDeleter.");
                result.Success     = false;
                result.Description = ServicesStrings.AsyncAccountDelete_Fail;
            }

            return(result);
        }
Пример #2
0
        private async Task <ActionResult> DeleteAndCheckSuccess(User user)
        {
            DeleteAccountStatus accountDeleteStatus = await DeleteAccountService.DeleteAccountAsync(userToBeDeleted : user,
                                                                                                    userToExecuteTheDelete : user,
                                                                                                    orphanPackagePolicy : AccountDeletionOrphanPackagePolicy.UnlistOrphans);

            if (!accountDeleteStatus.Success)
            {
                TempData["RequestFailedMessage"] = Strings.AccountSelfDelete_Fail;
                return(RedirectToAction("DeleteRequest"));
            }
            OwinContext.Authentication.SignOut();
            return(SafeRedirect(Url.Home(false)));
        }
Пример #3
0
        public override async Task <ActionResult> RequestAccountDeletion(string accountName = null)
        {
            var user = GetAccount(accountName);

            if (user == null || user.IsDeleted)
            {
                return(HttpNotFound());
            }
            TelemetryService.TrackRequestForAccountDeletion(user);

            if (!user.Confirmed)
            {
                // Unconfirmed users can be deleted immediately without creating a support request.
                DeleteAccountStatus accountDeleteStatus = await DeleteAccountService.DeleteAccountAsync(userToBeDeleted : user,
                                                                                                        userToExecuteTheDelete : user,
                                                                                                        orphanPackagePolicy : AccountDeletionOrphanPackagePolicy.UnlistOrphans);

                if (!accountDeleteStatus.Success)
                {
                    TempData["RequestFailedMessage"] = Strings.AccountSelfDelete_Fail;
                    return(RedirectToAction("DeleteRequest"));
                }
                OwinContext.Authentication.SignOut();
                return(SafeRedirect(Url.Home(false)));
            }

            var isSupportRequestCreated = await _supportRequestService.TryAddDeleteSupportRequestAsync(user);

            if (isSupportRequestCreated)
            {
                var emailMessage = new AccountDeleteNoticeMessage(MessageServiceConfiguration, user);
                await MessageService.SendMessageAsync(emailMessage);
            }
            else
            {
                TempData["RequestFailedMessage"] = Strings.AccountDelete_CreateSupportRequestFails;
            }

            return(RedirectToAction(nameof(DeleteRequest)));
        }
            public async Task DeleteHappyAccount(bool shouldUnlist)
            {
                // Arrange
                string username   = "******";
                var    controller = GetController();
                var    fakes      = Get <Fakes>();
                var    testUser   = fakes.CreateUser(username);

                testUser.IsDeleted = false;
                testUser.Key       = 1;
                var adminUser = fakes.Admin;

                controller.SetCurrentUser(adminUser);

                var expectedStatus = new DeleteAccountStatus();

                GetMock <IDeleteAccountService>()
                .Setup(stub => stub.DeleteAccountAsync(
                           testUser,
                           adminUser,
                           shouldUnlist ? AccountDeletionOrphanPackagePolicy.UnlistOrphans : AccountDeletionOrphanPackagePolicy.KeepOrphans))
                .ReturnsAsync(expectedStatus);

                var model = new DeleteAccountAsAdminViewModel()
                {
                    AccountName  = username,
                    ShouldUnlist = shouldUnlist
                };

                // act
                var result = await controller.Delete(model);

                var status = ResultAssert.IsView <DeleteAccountStatus>(result, "DeleteAccountStatus");

                // Assert
                Assert.Equal(expectedStatus, status);
            }
 protected override void ReadPacketInternal(PacketBuffer buffer, PacketRole role)
 {
     StatusCode = (DeleteAccountStatus)buffer.ReadByte();
 }