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);