public async Task <DeleteAccountResponse> DeleteAccountAsync(ApiAuthentication auth, long accountId)
{
var _request = GetAccount(auth, accountId);
if (_request == null)
{
return(null);
}
var request = new DeleteAccountRequest
{
AccountId = accountId,
TimeStamp = _request.Account.TimeStamp,
};
try
{
SetAuthHelper.SetAuth(auth, request);
return(await Check().DeleteAccountAsync(request));
}
catch (Exception ex)
{
Log(new LogEventArgs(ServiceType.CustomerManagement, "DeleteAccountAsync", ex.Message, new { Request = request }, ex));
}
return(null);
}
public void DeleteAccount_InvalidPassword_ThrowsForbiddenException()
{
var user = new UserDto()
{
Id = 1
};
var delAccReq = new DeleteAccountRequest()
{
Password = "******"
};
//Arrange
Mock <IUserRepository> mockUserRepository = new Mock <IUserRepository>();
Mock <ILoginRepository> mockLoginRepository = new Mock <ILoginRepository>();
mockLoginRepository.Setup(l => l.HasUserAndToken(user.Id, It.IsAny <string>())).Returns(true);
mockUserRepository.Setup(u => u.IsPasswordCorrect(user.Id, delAccReq.Password)).Returns(false); //simulate wrong pass
var controller = new UserController(mockUserRepository.Object, mockLoginRepository.Object);
var requestMessage = new HttpRequestMessage();
requestMessage.Headers.Add("DiceGaming-Token", "token");
controller.Request = requestMessage;
controller.Configuration = new HttpConfiguration();
//Act / Assert
Assert.Throws <ForbiddenException>(() => controller.DeleteAccount(user.Id, delAccReq));
}
public async Task DeleteAccount_ValidPassword_AccountIsDeletedAndReturnsNoContentStatusCode()
{
var user = new UserDto()
{
Id = 1
};
var delAccReq = new DeleteAccountRequest()
{
Password = "******"
};
//Arrange
Mock <IUserRepository> mockUserRepository = new Mock <IUserRepository>();
Mock <ILoginRepository> mockLoginRepository = new Mock <ILoginRepository>();
mockLoginRepository.Setup(l => l.HasUserAndToken(user.Id, It.IsAny <string>())).Returns(true);
mockUserRepository.Setup(u => u.IsPasswordCorrect(user.Id, delAccReq.Password)).Returns(true);
var controller = new UserController(mockUserRepository.Object, mockLoginRepository.Object);
var requestMessage = new HttpRequestMessage();
requestMessage.Headers.Add("DiceGaming-Token", "token");
controller.Request = requestMessage;
controller.Configuration = new HttpConfiguration();
//Act
var response = await controller.DeleteAccount(user.Id, delAccReq);
//Assert
mockUserRepository.Verify(u => u.Delete(user.Id));
Assert.IsTrue(response.StatusCode == HttpStatusCode.NoContent);
}
internal virtual DeleteAccountResponse DeleteAccount(DeleteAccountRequest request)
{
var marshaller = DeleteAccountRequestMarshaller.Instance;
var unmarshaller = DeleteAccountResponseUnmarshaller.Instance;
return(Invoke <DeleteAccountRequest, DeleteAccountResponse>(request, marshaller, unmarshaller));
}
public DeleteAccountResponse DeleteAccount(DeleteAccountRequest request)
{
DeleteAccountResponse res = new DeleteAccountResponse();
string strSP = SqlCommandStore.uspDeleteAccount;
try
{
using (SqlCommand cmd = new SqlCommand(strSP))
{
cmd.Parameters.Add("AccountID", SqlDbType.BigInt).Value = (int)request.AccountID;
cmd.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
DataSet ds = DB.ExecuteSPDataSet(cmd);
res.Code = (ReturnCode)Convert.ToInt32(cmd.Parameters["@Return"].Value);
if (res.Code != ReturnCode.Success)
{
DB.RollBackTran();
return(res);
}
DB.CommitTran();
return(res);
}
}
catch (Exception ex)
{
LogWriter.WriteLogException(ex);
res.Code = ReturnCode.Fail;
return(res);
}
}
public DeleteAccountResponse DeleteAccount(DeleteAccountRequest request)
{
var response = new DeleteAccountResponse();
try
{
var userName = request.UserName;
var roles = Roles.GetRolesForUser(userName);
if (roles.Any())
{
Roles.RemoveUserFromRoles(userName, roles);
}
var membership = (SimpleMembershipProvider)Membership.Provider;
membership.DeleteAccount(userName); // deletes record from webpages_Membership table
membership.DeleteUser(userName, true); // deletes record from UserProfile table
response.Success = true;
}
catch (Exception ex)
{
this.exceptionHandler.HandleException(ex);
response.Message = Resources.Common.InternalServerError;
}
return(response);
}
public async Task <ActionResult> Delete(DeleteAccountRequest deleteAccountRequest)
{
var user = Session["user"] as UserModel;
if (user == null)
{
return(await Task.FromResult(RedirectToAction("Index", "Home")));
}
using (var client = new HttpClient())
{
var request = RequestHelper.GenerateRequestMessage($"api/users/{user.UserId}", HttpMethod.Delete, token: user.Token, json: deleteAccountRequest);
var response = await client.SendAsync(request);
var statusCode = response.StatusCode;
if (statusCode != HttpStatusCode.NoContent)
{
TempData["danger"] = "Error occurred while trying to delete your account!";
return(await Task.FromResult(RedirectToAction("Index", "Profile")));
}
else
{
// Remove session
Session["user"] = null;
foreach (var cookie in HttpContext.Request.Cookies.AllKeys)
{
HttpContext.Response.Cookies[cookie].Expires = DateTime.Now.AddDays(-1);
}
TempData["info"] = "Account deleted!";
return(await Task.FromResult(RedirectToAction("Index", "Home")));
}
}
}
public void CreateDeleteAccountRequest()
{
var deleteAccountRequest = new DeleteAccountRequest();
deleteAccountRequest.Password = "******";
deleteAccountRequest.Reason = "some reason";
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteAccount operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteAccount operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/chime-2018-05-01/DeleteAccount">REST API Reference for DeleteAccount Operation</seealso>
public virtual Task <DeleteAccountResponse> DeleteAccountAsync(DeleteAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = DeleteAccountRequestMarshaller.Instance;
var unmarshaller = DeleteAccountResponseUnmarshaller.Instance;
return(InvokeAsync <DeleteAccountRequest, DeleteAccountResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteAccount operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteAccount operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/chime-2018-05-01/DeleteAccount">REST API Reference for DeleteAccount Operation</seealso>
public virtual Task <DeleteAccountResponse> DeleteAccountAsync(DeleteAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteAccountRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteAccountResponseUnmarshaller.Instance;
return(InvokeAsync <DeleteAccountResponse>(request, options, cancellationToken));
}
internal virtual DeleteAccountResponse DeleteAccount(DeleteAccountRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteAccountRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteAccountResponseUnmarshaller.Instance;
return(Invoke <DeleteAccountResponse>(request, options));
}
public async Task<HttpResponseMessage> DeleteAccount(DeleteAccountRequest request)
{
using (var storageClient = new StorageManagementClient(new CertificateCloudCredentials(_subscriptionId, new X509Certificate2(
Convert.FromBase64String(_certificateBase64)))))
{
var response = await storageClient.StorageAccounts.DeleteAsync(request.AccountName);
return new HttpResponseMessage(response.StatusCode);
}
}
public async Task <DeleteAccountResponse> DeleteAccount(DeleteAccountRequest request)
{
var account = await this._repositoryAccount.Get(request.AccountId);
await this._repositoryAccount.Remove(account);
return(new DeleteAccountResponse {
});
}
public DeleteAccountResponse DeleteAccount(DeleteAccountRequest request)
{
DeleteAccountResponse res = new DeleteAccountResponse();
res = dao.DeleteAccount(new DeleteAccountRequest()
{
AccountID = request.AccountID
});
return(res);
}
public void DeleteAccount_ToDeleteAccount_Success()
{
Account account = AccountMockData.GetAccountClass();
mockAccountRepository.Setup(cr => cr.FindBy(It.IsAny <int>())).Returns(account);
DeleteAccountRequest req = new DeleteAccountRequest(10);
DeleteAccountResponse response = accountService.DeleteAccount(req);
mockRepository.VerifyAll();
Assert.AreEqual(null, response.Exception);
}
public async Task <DeleteAccountResponse> DeleteAccountAsync(
long accountId,
byte[] timeStamp)
{
var request = new DeleteAccountRequest
{
AccountId = accountId,
TimeStamp = timeStamp
};
return(await CustomerManagementService.CallAsync((s, r) => s.DeleteAccountAsync(r), request));
}
/// <summary>Snippet for DeleteAccount</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void DeleteAccountRequestObject()
{
// Create client
AnalyticsAdminServiceClient analyticsAdminServiceClient = AnalyticsAdminServiceClient.Create();
// Initialize request argument(s)
DeleteAccountRequest request = new DeleteAccountRequest
{
AccountName = AccountName.FromAccount("[ACCOUNT]"),
};
// Make the request
analyticsAdminServiceClient.DeleteAccount(request);
}
public async Task <IActionResult> DeleteUserAccount([FromBody] DeleteAccountRequest deleteAccount)
{
try
{
await _userServices.DeleteUserAccount(deleteAccount.UserId);
return(Ok());
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
/// <summary>
/// 本接口（DeleteAccount）用于删除云数据库账号。用户名+host唯一确定一个账号。
/// </summary>
/// <param name="req">参考<see cref="DeleteAccountRequest"/></param>
/// <returns>参考<see cref="DeleteAccountResponse"/>实例</returns>
public async Task<DeleteAccountResponse> DeleteAccount(DeleteAccountRequest req)
{
JsonResponseModel<DeleteAccountResponse> rsp = null;
try
{
var strResp = await this.InternalRequest(req, "DeleteAccount");
rsp = JsonConvert.DeserializeObject<JsonResponseModel<DeleteAccountResponse>>(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return rsp.Response;
}
public override async Task <Empty> DeleteAccount(DeleteAccountRequest request, ServerCallContext context)
{
CheckIfArgumentIsNull(ref context);
var reqestObject = new AuthorizedRequestObject <DeleteAccountRequest, Empty>(request)
{
UserId = context.GetHttpContext().User.GetUserId()
};
Empty reply = await mediator.Send(reqestObject).ConfigureAwait(false);
if (reqestObject.StatusCode != StatusCode.OK)
{
context.Status = new Status(reqestObject.StatusCode, reqestObject.Detail);
}
return(reply);
}
public ActionResult <ApiResponse> DeleteAccount1Step(DeleteAccountRequest model)
{
User authUser = _userService.GetById(GetUserIdFromJwtToken());
var passwordIsValid = _userService.VerifyPasswordHash(model.Password, Convert.FromBase64String(authUser.Password), Convert.FromBase64String(authUser.PasswordSalt));
if (!passwordIsValid)
{
throw new AuthenticationException("Password is incorrect");
}
_userService.CreateAndSendAuthorizationToken(GetUserIdFromJwtToken(), model.Password);
return(Ok(new ApiResponse
{
Success = true
}));
}
public async Task <SuccessResponse> DeleteAccount(DeleteAccountRequest deleteAccountRequest)
{
LoginRequest loginRequest = new LoginRequest()
{
userName = _configuration.GetSection("ApplicationSettings")["UserName"],
password = _configuration.GetSection("ApplicationSettings")["Password"]
};
LoginResponse loginResponse = await _authenticationService.Login(loginRequest);
ApiEndPoint = _configuration.GetSection("ApplicationSettings")["ApiEndPoint"] + "users/DeleteAccount";
var response = await Task.Run(async() =>
{
var result = await PostAsync(deleteAccountRequest, loginResponse.token);
return(result);
});
return(response);
}
public Task <HttpResponseMessage> DeleteAccount(int id, [FromBody] DeleteAccountRequest delAccountRequest)
{
string token = Request.Headers.GetValues("OnlineCasino-Token").FirstOrDefault();
if (!loginRepository.HasUserAndToken(id, token))
{
throw new ForbiddenException();
}
if (!userRepository.IsPasswordCorrect(id, delAccountRequest.Password))
{
throw new ForbiddenException();
}
userRepository.Delete(id);
return(Task.FromResult(Request.CreateResponse(HttpStatusCode.NoContent)));
}
public async Task <IActionResult> Delete([FromBody] DeleteAccountRequest request)
{
int id = User.GetUserId();
try
{
var reqestObject = new AuthorizedRequestObject <DeleteAccountRequest, Empty>(request)
{
UserId = User.GetUserId()
};
await mediator.Send(reqestObject).ConfigureAwait(false);
return(Ok());
}
catch (ArgumentNullException e)
{
return(BadRequest(e.Message));
}
}
public ActionResult <ApiResponse> DeleteAccount2Step(DeleteAccountRequest model)
{
bool tokenIsValid = _userService.ValidateToken(model.Token, model.Password);
if (!tokenIsValid)
{
throw new UserServiceException("Verification token is invalid or expired");
}
var isDeleted = _userService.DeleteUser(GetUserIdFromJwtToken());
if (!isDeleted)
{
throw new UserServiceException("There was an error during user delete.Try again or contact support.");
}
return(Ok(new ApiResponse
{
Success = true
}));
}
public ActionResult DeleteAccount(DeleteAccountRequest request)
{
return(View());
}
public async Task <SuccessResponse> DeleteAccount(DeleteAccountRequest deleteAccountRequest)
{
var result = await _userService.DeleteAccount(deleteAccountRequest);
return(result);
}
public Task DeleteAccountAsync(DeleteAccountRequest request)
{
return(SendAsync <DeleteAccountRequest, object>(HttpMethod.Delete, "/accounts", request, true, false));
}
public DeleteAccountResponse DeleteAccount(DeleteAccountRequest request)
{
var response = new DeleteAccountResponse();
try
{
var userName = request.UserName;
var roles = Roles.GetRolesForUser(userName);
if (roles.Any())
{
Roles.RemoveUserFromRoles(userName, roles);
}
var membership = (SimpleMembershipProvider)Membership.Provider;
membership.DeleteAccount(userName); // deletes record from webpages_Membership table
membership.DeleteUser(userName, true); // deletes record from UserProfile table
}
catch (Exception ex)
{
response.Status = StatusCode.InternalServerError;
this.exceptionHandler.HandleException(ex);
}
return response;
}
public async Task RegisterNewUserAndLoginAndDeleteAccount()
{
var user = new UserDto()
{
Username = "******",
Password = "******",
FullName = "Fast Tester",
Email = "*****@*****.**"
};
// Register new user
// Arrange
var registerRequest = new RegisterRequest()
{
Username = user.Username,
Password = user.Password,
FullName = user.FullName,
Email = user.Email
};
var json = JsonConvert.SerializeObject(registerRequest);
var request = TestHelper.GenerateRequestMessage(url: "http://localhost/api/users/",
method: HttpMethod.Post,
json: json);
// Act
var response = await TestHelper.Client.SendAsync(request);
// Assert
Assert.IsTrue(response.StatusCode == HttpStatusCode.Created);
string content = await response.Content.ReadAsStringAsync();
var jsonResponse = JsonConvert.DeserializeObject <Dictionary <string, string> >(content);
Assert.IsTrue(object.Equals(jsonResponse["username"], user.Username));
Assert.IsTrue(object.Equals(jsonResponse["fullName"], user.FullName));
Assert.IsTrue(object.Equals(jsonResponse["email"], user.Email));
user.Id = int.Parse(jsonResponse["userId"]);
//Login into account
// Arrange 2
var loginRequest = new LoginRequest()
{
Username = user.Username,
Password = user.Password
};
json = JsonConvert.SerializeObject(loginRequest);
request = TestHelper.GenerateRequestMessage(url: "http://localhost/api/logins/",
method: HttpMethod.Post,
json: json);
// Act 2
response = await TestHelper.Client.SendAsync(request);
// Assert 2
Assert.IsTrue(response.StatusCode == HttpStatusCode.Created);
content = await response.Content.ReadAsStringAsync();
jsonResponse = JsonConvert.DeserializeObject <Dictionary <string, string> >(content);
string token = jsonResponse["token"];
// Delete account
// Arrange 3
var deleteRequest = new DeleteAccountRequest()
{
Password = user.Password
};
json = JsonConvert.SerializeObject(deleteRequest);
request = TestHelper.GenerateRequestMessage(url: "http://localhost/api/users/" + user.Id.ToString(),
method: HttpMethod.Delete,
token: token,
json: json);
// Act 3
response = await TestHelper.Client.SendAsync(request);
// Assert 3
Assert.IsTrue(response.StatusCode == HttpStatusCode.NoContent);
using (var db = new OnlineCasinoDb())
{
var deletedUser = db.Users.FirstOrDefault(u => u.Id == user.Id);
Assert.IsTrue(deletedUser == null);
}
}
public Task <DeleteAccountResponse> DeleteAccountAsync(DeleteAccountRequest request)
{
throw new System.NotImplementedException();
}
public async Task <IActionResult> Delete([FromBody] DeleteAccountRequest request) => await mediator.AuthorizeHandlerActionResult <DeleteAccountRequest, Empty>(request, User).ConfigureAwait(false);
