public async Task Execute(WithdrawInput input) { IAccount account; IDebit debit; try { account = await _accountRepository.Get(input.AccountId); debit = account.Withdraw(_entityFactory, input.Amount); } catch (AccountNotFoundException notFoundEx) { _outputPort.NotFound(notFoundEx.Message); return; } catch (MoneyShouldBePositiveException outOfBalanceEx) { _outputPort.OutOfBalance(outOfBalanceEx.Message); return; } await _accountRepository.Update(account, debit); await _unitOfWork.Save(); BuildOutput(debit, account); }
public override Empty Withdraw(WithdrawInput input) { State.TokenContract.TransferToContract.Send(new TransferToContractInput { Symbol = State.Symbol.Value, Amount = input.Amount }); State.TokenContract.Transfer.Send(new TransferInput { To = Context.Sender, Symbol = input.Symbol, Amount = input.Amount }); State.TokenHolderContract.RemoveBeneficiary.Send(new RemoveTokenHolderBeneficiaryInput { Beneficiary = Context.Sender, Amount = input.Amount }); // Update profile. var profile = State.Profiles[Context.Sender]; profile.Records.Add(new Record { Type = RecordType.Withdraw, Timestamp = Context.CurrentBlockTime, Description = $"{State.Symbol.Value} -{input.Amount}" }); State.Profiles[Context.Sender] = profile; return(new Empty()); }
public async Task Execute(WithdrawInput input) { IAccount account = await _accountRepository.Get(input.AccountId); if (account == null) { _outputHandler.Error($"The account {input.AccountId} does not exist or is already closed."); return; } IDebit debit = account.Withdraw(_entityFactory, input.Amount); if (debit == null) { _outputHandler.Error($"The account {input.AccountId} does not have enough funds to withdraw {input.Amount}."); return; } await _accountRepository.Update(account, debit); await _unitOfWork.Save(); WithdrawOutput output = new WithdrawOutput( debit, account.GetCurrentBalance() ); _outputHandler.Default(output); }
/// <summary> /// Withdraw the Votes. /// first,mark the related record IsWithdrawn. /// second,delete the vote form ActiveVotes and add the vote to withdrawnVotes. /// finally,unlock the token that Locked in the VotingItem /// </summary> /// <param name="input"></param> /// <returns></returns> public override Empty Withdraw(WithdrawInput input) { var votingRecord = State.VotingRecords[input.VoteId]; Assert(votingRecord != null, "Voting record not found."); var votingItem = State.VotingItems[votingRecord.VotingItemId]; if (votingItem.IsLockToken) { Assert(votingRecord.Voter == Context.Sender, "No permission to withdraw votes of others."); } Assert(votingItem.CurrentSnapshotNumber > votingRecord.SnapshotNumber, "Cannot withdraw votes of on-going voting item."); // Update VotingRecord. votingRecord.IsWithdrawn = true; votingRecord.WithdrawTimestamp = Context.CurrentBlockTime; State.VotingRecords[input.VoteId] = votingRecord; var votingResultHash = GetVotingResultHash(votingRecord.VotingItemId, votingRecord.SnapshotNumber); var votedItems = State.VotedItemsMap[votingRecord.Voter]; votedItems.VotedItemVoteIds[votingItem.VotingItemId.ToHex()].ActiveVotes.Remove(input.VoteId); votedItems.VotedItemVoteIds[votingItem.VotingItemId.ToHex()].WithdrawnVotes.Add(input.VoteId); State.VotedItemsMap[votingRecord.Voter] = votedItems; var votingResult = State.VotingResults[votingResultHash]; votingResult.Results[votingRecord.Option] = votingResult.Results[votingRecord.Option].Sub(votingRecord.Amount); if (!votedItems.VotedItemVoteIds[votingRecord.VotingItemId.ToHex()].ActiveVotes.Any()) { votingResult.VotersCount = votingResult.VotersCount.Sub(1); } votingResult.VotesAmount = votingResult.VotesAmount.Sub(votingRecord.Amount); State.VotingResults[votingResultHash] = votingResult; if (votingItem.IsLockToken) { State.TokenContract.Unlock.Send(new UnlockInput { Address = votingRecord.Voter, Symbol = votingItem.AcceptedCurrency, Amount = votingRecord.Amount, LockId = input.VoteId, Usage = $"Withdraw votes for {votingRecord.VotingItemId}" }); } Context.Fire(new Withdrawn { VoteId = input.VoteId }); return(new Empty()); }
static async Task WithdrawTest() { try { HttpHelp httpHelp = new HttpHelp(); string url = host + "/api/v1/withdraw"; WithdrawInput inputDto = new WithdrawInput { Symbol = "VHKD", Address = "VBssvPs5ayEzYMfBxVN3Ux2uGzgBBVBR2S", Amount = 1 }; string input = JsonConvert.SerializeObject(inputDto); var response = httpHelp.HttpPost <OperateMessage <string> >(url, ApiKey, input, ApiSign.CreateSign(SecretKey, input) ); Console.WriteLine($"code:{response.code}"); Console.WriteLine($"result:{response.result}"); Console.WriteLine($"data:{response.data.ToString()}"); } catch (Exception ex) { Console.WriteLine($"{nameof(GetTickerTest)}出错:{ex.Message}"); } }
public async Task Execute(WithdrawInput input) { IAccount account = await _accountRepository.Get(input.AccountId); if (account == null) { _outputHandler.Error($"The account {input.AccountId} does not exist or is already closed."); return; } IDebit debit = account.Withdraw(_entityFactory, input.Amount); if (debit == null) { _outputHandler.Error($"The account {input.AccountId} does not have enough funds to withdraw {input.Amount}."); return; } await _accountRepository.Update(account, debit); // Publish the event to the enterprice service bus await _serviceBus.PublishEventAsync(new Shared.Events.WithdrawCompleted() { AccountId = input.AccountId, Amount = input.Amount.ToMoney().ToDecimal() }); await _unitOfWork.Save(); WithdrawOutput output = new WithdrawOutput( debit, account.GetCurrentBalance() ); _outputHandler.Default(output); }
/// <summary> /// Executes the Use Case. /// </summary> /// <param name="input">Input Message.</param> /// <returns>Task.</returns> public async Task Execute(WithdrawInput input) { if (input is null) { this._outputPort.WriteError(Messages.InputIsNull); return; } try { var account = await this._accountRepository.GetAccount(input.AccountId) .ConfigureAwait(false); var debit = await this._accountService.Withdraw(account, input.Amount) .ConfigureAwait(false); await this._unitOfWork.Save() .ConfigureAwait(false); this.BuildOutput(debit, account); } catch (AccountNotFoundException notFoundEx) { this._outputPort.NotFound(notFoundEx.Message); } catch (MoneyShouldBePositiveException outOfBalanceEx) { this._outputPort.OutOfBalance(outOfBalanceEx.Message); } }
public async Task <IActionResult> Withdraw([FromBody] WithdrawRequest message) { var request = new WithdrawInput(message.AccountId, message.Amount); await withdrawInput.Process(request); return(withdrawPresenter.ViewModel); }
public void GivenValidData_InputCreated() { var actual = new WithdrawInput( new AccountId(Guid.NewGuid()), new PositiveMoney(10)); Assert.NotNull(actual); }
public async Task <IActionResult> Withdraw([FromForm][Required] WithdrawRequest request) { var input = new WithdrawInput( new AccountId(request.AccountId), new PositiveMoney(request.Amount)); await _mediator.PublishAsync(input); return(_presenter.ViewModel); }
public void GivenValidData_InputCreated() { var actual = new WithdrawInput( Guid.NewGuid(), new PositiveAmount(10) ); Assert.NotNull(actual); }
public override Empty Withdraw(WithdrawInput input) { var votingRecord = State.VotingRecords[input.VoteId]; Assert(votingRecord != null, "Voting record not found."); var votingEventHash = new VotingEvent { Topic = votingRecord.Topic, Sponsor = votingRecord.Sponsor }.GetHash(); var votingEvent = State.VotingEvents[votingEventHash]; Assert(votingEvent.CurrentEpoch > votingRecord.EpochNumber, "Cannot withdraw votes of on-going voting event."); // Update VotingRecord. votingRecord.IsWithdrawn = true; votingRecord.WithdrawTimestamp = Context.CurrentBlockTime.ToTimestamp(); State.VotingRecords[input.VoteId] = votingRecord; var votingGoingHash = new VotingResult { Sponsor = votingRecord.Sponsor, Topic = votingRecord.Topic, EpochNumber = votingRecord.EpochNumber }.GetHash(); var votingHistories = UpdateHistoryAfterWithdrawing(votingRecord.Voter, votingEventHash, input.VoteId); var votingResult = State.VotingResults[votingGoingHash]; votingResult.Results[votingRecord.Option] -= votingRecord.Amount; if (!votingHistories.Votes[votingEventHash.ToHex()].ActiveVotes.Any()) { votingResult.VotersCount -= 1; } State.VotingResults[votingGoingHash] = votingResult; if (!State.VotingEvents[votingEventHash].Delegated) { State.TokenContract.Unlock.Send(new UnlockInput { From = votingRecord.Voter, Symbol = votingRecord.Currency, Amount = votingRecord.Amount, LockId = input.VoteId, To = Context.Self, Usage = $"Withdraw votes for {votingRecord.Topic}" }); } return(new Empty()); }
public async Task <IActionResult> Withdraw([FromBody][Required] WithdrawRequest request) { var withdrawInput = new WithdrawInput( request.AccountId, new PositiveMoney(request.Amount) ); await _withdrawUseCase.Execute(withdrawInput); return(_presenter.ViewModel); }
public async Task Execute(WithdrawInput input) { var account = await _accountRepository.Get(input.AccountId); var debit = account.Withdraw(_entityFactory, input.Amount); await _accountRepository.Update(account, debit); await _unitOfWork.Save(); BuildOutput(debit, account); }
private async Task <TransactionResult> WithdrawWithException(ECKeyPair owner, Hash voteId) { var voterStub = GetVoteContractTester(owner); var input = new WithdrawInput { VoteId = voteId }; var withdrawResult = (await voterStub.Withdraw.SendWithExceptionAsync(input)).TransactionResult; return(withdrawResult); }
public async Task <IActionResult> Withdraw( [FromServices] IMediator mediator, [FromServices] WithdrawPresenter presenter, [FromForm][Required] WithdrawRequest request) { var input = new WithdrawInput( request.AccountId, request.Amount); await mediator.PublishAsync(input) .ConfigureAwait(false); return(presenter.ViewModel); }
public virtual async Task WithdrawAsync(Guid id, WithdrawInput input) { var account = await _repository.GetAsync(id); if (account.UserId != CurrentUser.GetId()) { throw new AbpAuthorizationException(); } var accountWithdrawalManager = ServiceProvider.GetRequiredService <IAccountWithdrawalManager>(); await accountWithdrawalManager.StartWithdrawalAsync(account, input.WithdrawalMethod, input.Amount, input.ExtraProperties); }
/// <summary> /// Executes the Use Case. /// </summary> /// <param name="input">Input Message.</param> /// <returns>Task.</returns> public async Task Execute(WithdrawInput input) { try { var account = await this._accountRepository.Get(input.AccountId); var debit = await this._accountService.Withdraw(account, input.Amount); await this._unitOfWork.Save(); this.BuildOutput(debit, account); } catch (AccountNotFoundException notFoundEx) { this._outputPort.NotFound(notFoundEx.Message); return; } catch (MoneyShouldBePositiveException outOfBalanceEx) { this._outputPort.OutOfBalance(outOfBalanceEx.Message); return; } }
public void GivenValidData_InputCreated() { WithdrawInput actual = new WithdrawInput(Guid.NewGuid(), 10); Assert.NotNull(actual); }
public virtual Task WithdrawAsync(Guid id, WithdrawInput input) { return(_service.WithdrawAsync(id, input)); }