Exemple #1
0
        public async Task <AppResponse> CloseAccountAsync(CloseAccountRequest model, CancellationToken cancellationToken = default)
        {
            var user = await GetByUsernameAsync(model.UserName);

            if (user != null)
            {
                return(new AppResponse
                {
                    Status = HttpStatusCode.NotFound,
                    Message = "Could not find a user",
                });
            }
            //user.IsEnabled = false;

            //dataContext.Update(user);

            //await dataContext.SaveChangesAsync(cancellationToken);

            try
            {
                await userRepository.CloseAccountAsync(user);

                return(new AppResponse {
                    Status = HttpStatusCode.Accepted
                });
            }
            catch (Exception)
            {
                return(new AppResponse
                {
                    Status = HttpStatusCode.InternalServerError,
                    Message = "Could not process to save a user data.",
                });
            }
        }
Exemple #2
0
        public async Task <CloseAccountResponse> CloseAccount(CloseAccountRequest request)
        {
            var logDic = new Dictionary <string, object>
            {
                { "AccountIdentifier", request.AccountIdentifier },
                { "Option", request.Option.ToString() },
            };
            var endpointUrl = $"{ConfigManager.Instance.GetApiEndpoint("CRMCoreService")}/Account/closeAccount";

            try
            {
                var handler = new HttpClientHandler
                {
                    UseDefaultCredentials = true,
                    PreAuthenticate       = true
                };
                _apiClient.Client = new HttpClient(handler);
                var response = await _apiClient.PostAsync <CloseAccountResponse, CloseAccountRequest>(new Uri(endpointUrl), request, LogOptionEnum.FullLog, logDic);

                return(HandleNoSuccessResponse <CloseAccountResponse>(response, logDic, MethodBase.GetCurrentMethod().Name) ? null : response);
            }
            catch (Exception ex)
            {
                logDic.Add("EndPointUrl", endpointUrl);
                throw new ExternalErrorException(
                          "Error when calling CloseAccount route from CRMcoreService",
                          new LogObject("CRMCoreService_CloseAccount",
                                        logDic), ex);
                throw;
            }
        }
Exemple #3
0
        /// <summary>
        /// Post /closeAccount API call
        /// </summary>
        /// <param name="closeAccountRequest"></param>
        /// <returns>CloseAccountResponse</returns>
        public CloseAccountResponse CloseAccount(CloseAccountRequest closeAccountRequest)
        {
            var jsonRequest  = Util.JsonOperation.SerializeRequest(closeAccountRequest);
            var jsonResponse = _closeAccount.Request(jsonRequest);

            return(JsonConvert.DeserializeObject <CloseAccountResponse>(jsonResponse));
        }
        public async Task <IActionResult> Delete(CloseAccountRequest model)
        {
            if (ModelState.IsValid)
            {
                await _userService.Delete(model);

                return(Ok());
            }
            return(BadRequest("Faild"));
        }
Exemple #5
0
        public void TestCloseAccountSuccess()
        {
            var client               = CreateMockTestClientNullRequiredFieldsRequest("Mocks/marketpay/account/close-account-success.json");
            var account              = new Account(client);
            var closeAccountRequest  = new CloseAccountRequest(accountCode: "123456");
            var closeAccountResponse = account.CloseAccount(closeAccountRequest);

            Assert.IsNotNull(closeAccountResponse);
            Assert.AreEqual(closeAccountResponse.PspReference, "8515810799236011");
            Assert.AreEqual(closeAccountResponse.Status, CloseAccountResponse.StatusEnum.Closed);
        }
Exemple #6
0
        public override async Task <CloseAccountResponse> CloseAccount(CloseAccountRequest closeAccountRequest, ServerCallContext context)
        {
            Log.Information("CloseAccount called via gRPC remote service {@closeAccountRequest}", closeAccountRequest);

            var closeAccountCommand = _mapper.Map <CloseAccountCommand>(closeAccountRequest);
            var result = await _mediator.Send(closeAccountCommand);

            CloseAccountResponse closeAccountResponse = _mapper.Map <CloseAccountResponse>(result);

            return(closeAccountResponse);
        }
Exemple #7
0
        /**
         * Close account.
         */
        internal async Task <APIGatewayProxyResponse> CloseAccount(IDataStores dataStores,
                                                                   IDictionary <string, string> requestHeaders,
                                                                   JObject requestBody)
        {
            Debug.Untested();
            Debug.AssertValid(dataStores);
            Debug.AssertValid(requestHeaders);
            Debug.AssertValidOrNull(requestBody);

            try {
                // Log call
                LoggingHelper.LogMessage($"UserIdentityService::CloseAccount()");

                // Get the NoSQL DB client
                AmazonDynamoDBClient dbClient = (AmazonDynamoDBClient)dataStores.GetNoSQLDataStore().GetDBClient();
                Debug.AssertValid(dbClient);

                // Check inputs
                CloseAccountRequest closeAccountRequest = UserIdentityService_CloseAccount_LogicLayer.CheckValidCloseAccountRequest(requestBody);
                Debug.AssertValid(closeAccountRequest);

                // Check authenticated endpoint security
                string loggedInUserId = await APIHelper.CheckLoggedIn(dbClient, requestHeaders);

                Debug.AssertID(loggedInUserId);

                // Perform logic
                await UserIdentityService_CloseAccount_LogicLayer.CloseAccount(dbClient, loggedInUserId, closeAccountRequest);

                // Respond
                return(new APIGatewayProxyResponse {
                    StatusCode = APIHelper.STATUS_CODE_NO_CONTENT
                });
            } catch (Exception exception) {
                Debug.Tested();
                if (exception.Message == IdentityServiceLogicLayer.ERROR_INCORRECT_PASSWORD)
                {
                    Debug.Untested();
                    //??--return StatusCode(APIHelper.STATUS_CODE_UNAUTHORIZED, new GeneralErrorResponse { error = IdentityServiceLogicLayer.INCORRECT_PASSWORD });
                    //??--return Unauthorized();
                    return(new APIGatewayProxyResponse {
                        StatusCode = APIHelper.STATUS_CODE_UNAUTHORIZED,
                        Body = $"{{ error = \"{IdentityServiceLogicLayer.INCORRECT_PASSWORD}\"}}"
                    });
                }
                else
                {
                    Debug.Tested();
                    return(APIHelper.ResponseFromException(exception));
                }
            }
        }
        public async Task AdGroupLeft(int AccountId, int CampaignId, int AdGroupId)
        {
            var request = new CloseAccountRequest
            {
                AccountKey = $"{AccountId}:{CampaignId}:{AdGroupId}"
            };

            try
            {
                await _rpcClient.CloseAccountAsync(request);
            }
            catch (RpcException ex)
            {
                _log.Error($"Failed to close account {request.AccountKey}", ex);
                throw new BillingControllerException($"Failed to close account {request.AccountKey}", ex);
            }
        }
        public async Task Delete(CloseAccountRequest model)
        {
            var user = _userManager.Users.SingleOrDefault(x => x.Name == model.Name);

            if (user != null)
            {
                if (model.IsRememberPassword)
                {
                    bool isChecked = await _userManager.CheckPasswordAsync(user, model.Password);

                    if (isChecked)
                    {
                        // Wait for implement
                    }
                }

                var result = await _userManager.DeleteAsync(user);

                if (result.Succeeded)
                {
                    var token = GenerateJwtToken(user);
                }
            }
        }
        public async Task <IHttpActionResult> CloseAccount([FromBody] CloseAccountRequest request)
        {
            var response = await CloseAccountManager.Execute(request);

            return(CreateResponse(response));
        }
        /**
         * Close account.
         */
        public static async Task CloseAccount(AmazonDynamoDBClient dbClient, string loggedInUserId, CloseAccountRequest closeAccountRequest)
        {
            Debug.Tested();
            Debug.AssertValid(dbClient);
            Debug.AssertID(loggedInUserId);
            Debug.AssertValid(closeAccountRequest);
            Debug.AssertString(closeAccountRequest.password);

            // Load the user
            User user = await IdentityServiceLogicLayer.FindUserByID(dbClient, loggedInUserId);

            Debug.AssertValid(user);
            Debug.AssertNull(user.Closed);

            // Check the password
            if (user.PasswordHash == Helper.Hash(closeAccountRequest.password))
            {
                // Make changes
                user.Closed = DateTime.Now;

                // Save the user
                await IdentityServiceDataLayer.SaveUser(dbClient, user);

                // Actually log user out
                await IdentityServiceLogicLayer.InvalidateUserAccessTokens(dbClient, loggedInUserId);
            }
            else
            {
                Debug.Untested();
                throw new Exception(IdentityServiceLogicLayer.ERROR_INCORRECT_PASSWORD);
            }
        }