public async Task <WireTransferDto> Handle(RegisterWireTransferCommand command,
CancellationToken cancellationToken)
{
try
{
var wireTransferRegistered =
await WireTransfer.AddAmountTransferOnBeneficiaryBalanceAsync(
command.Request.WrapToWireTransfer(),
_beneficiaryAccountBalance, _accountUniquenessChecker);
var result = command.Request.SeedRelationships(wireTransferRegistered);
await _repository.RegisterIncomingTransfer(wireTransferRegistered);
await _mediator.Publish(new PublishWireTransferOnTopicNotification(result),
cancellationToken);
return(result);
}
catch (BusinessRuleValidationException exception)
{
await _mediator.Publish(
new RegisterRejectedTransferNotification(command.Request.WrapToWireTransfer(), exception),
cancellationToken);
throw;
}
}
public async Task <Guid> AddAmountToBeneficiaryBalanceAsync(WireTransfer wireTransfer)
{
var transactionId = await _transactionApiConfiguration.Url
.AppendPathSegment(_transactionApiConfiguration.CreateTransactionPathSegment)
.ConfigureRequest(settings =>
{
settings.BeforeCall = call =>
{
_logging.Information(call.Request.RequestUri);
var transactionIdResponse = GetTransactionId(wireTransfer);
if (transactionIdResponse != null)
{
throw new DuplicateException(
"Cannot create another transaction for the same wire transfer",
DuplicateRuleValidationEnumeration.ERROR_WIRE_TRANSFER_TRANSACTION_DUPLICATED);
}
};
})
.PostJsonAsync(new
{
IdContaBancaria = wireTransfer.BeneficiaryBankAccount.BankAccountLegacyId.Value,
TipoOperacao = WireTransferTypeOperation,
TipoLancamento = WireTransferTypeTransaction,
Descricao = $"Recebeu de {wireTransfer.SenderBankAccount.BankAccountHolder.HolderName}",
Valor = wireTransfer.Amount.Value,
IdCategoria = WireTransferCategoryId,
DataTransacao = DateTime.Now,
UniqueId = wireTransfer.ProtocolTrackable.ProtocolNumber
}).ReceiveJson <TransactionIdResponse>();
return(transactionId.TransactionId);
}
private TransactionIdResponse GetTransactionId(WireTransfer wireTransfer)
{
return(_transactionApiConfiguration.Url
.AppendPathSegment(_transactionApiConfiguration.GetDetailsTransactionPathSegment)
.SetQueryParam("bankAccountId", wireTransfer.BeneficiaryBankAccount.BankAccountLegacyId.Value)
.SetQueryParam("brokerId", WireTransferBrokerId)
.SetQueryParam("uniqueId", wireTransfer.ProtocolTrackable.ProtocolNumber)
.GetJsonAsync <TransactionIdResponse>().GetAwaiter().GetResult());
}
public void Can_create_WireTransfer_Command()
{
var id = Guid.NewGuid();
var funds = 300;
var @command = new WireTransfer(id, funds);
Assert.NotNull(@command);
Assert.Equal(id, @command.AccountId);
Assert.Equal(funds, @command.Funds);
}
public CommandResponse Handle(WireTransfer command)
{
if (!_repository.TryGetById <AccountAggregate.BankAccount>(command.AccountId, out var account))
{
throw new InvalidOperationException("No account with such ID");
}
account.TransferWire(command.Funds, new WireTransferred(command.AccountId, command.Funds));
_repository.Save(account);
return(command.Succeed());
}
private void HandleItems(Point coord)
{
WireTransfer transfer = wireSlower.getWireTransfer(coord);
List <RoomItem> items = new List <RoomItem>(room.GetGameMap().GetCoordinatedItems(coord));
foreach (RoomItem item in items)
{
item.Interactor.OnTrigger(null, item, 0, true);
}
items.Clear();
items = null;
}
public async Task AcceptPropertySetWithTransientObjectAsync()
{
Order order;
using (var s = OpenSession())
{
order = await(s.GetAsync <Order>(1));
}
var newPayment = new WireTransfer();
order.Payment = newPayment;
Assert.That(order.Payment, Is.EqualTo(newPayment));
}
public void AcceptPropertySetWithTransientObject()
{
Order order;
using (var s = OpenSession())
{
order = s.Get <Order>(1);
}
var newPayment = new WireTransfer();
order.Payment = newPayment;
Assert.That(order.Payment, Is.EqualTo(newPayment));
}
public async Task RegisterIncomingTransfer(WireTransfer wireTransfer)
{
var connection = _connectionFactory.GetOpenSqlConnection();
var wireTransferRejectedExists = connection.QueryFirstOrDefault <bool>(
$@"SELECT COUNT(1) FROM {DbNames.WireTransfersIn} WHERE [WIRE_TRANSFER_IN_UUID] = @WireTransferId",
new { WireTransferId = wireTransfer.Id.Value });
if (wireTransferRejectedExists)
{
throw new DuplicateException("There is already a wire transfer with the same id",
DuplicateRuleValidationEnumeration.ERROR_WIRE_TRANSFER_DUPLICATED);
}
var sqlInsert = @$ "INSERT INTO {DbNames.WireTransfersIn} (
/// <summary>
/// Populate <see cref="WireTransferDto" /> with transaction uuid and remove beneficiary details from result
/// </summary>
/// <param name="wireTransferDto"></param>
/// <param name="wireTransfer"></param>
/// <returns></returns>
public static WireTransferDto SeedRelationships(this WireTransferDto wireTransferDto,
WireTransfer wireTransfer)
{
wireTransferDto.Transaction = new TransactionDto
{
Id = Guid.Parse(wireTransfer.TransactionId.Value.ToString())
};
wireTransferDto.Account = new AccountDto
{
Id = Guid.Parse(wireTransfer.BeneficiaryBankAccount.BankAccountId.Value.ToString())
};
wireTransferDto.Beneficiary = null;
return(wireTransferDto);
}
protected override void OnSetUp()
{
using (var s = OpenSession())
using (var tx = s.BeginTransaction())
{
var wireTransfer = new WireTransfer
{
Id = 1
};
s.Persist(wireTransfer);
s.Persist(new Order
{
Id = 1,
Payment = wireTransfer
});
tx.Commit();
}
}
protected override void OnSetUp()
{
using (var s = OpenSession())
using (var tx = s.BeginTransaction())
{
var wireTransfer = new WireTransfer
{
Id = 1
};
s.Persist(wireTransfer);
s.Persist(new Order
{
Id = 1,
Payment = wireTransfer
});
tx.Commit();
}
}
internal void TriggerOnWire(Point location)
{
WireTransfer transferItem = wireSlower.getWireTransfer(location);
List <Point> pointsToTrigger;
WireCurrentTransfer transferType = WireCurrentTransfer.DOWN | WireCurrentTransfer.LEFT | WireCurrentTransfer.RIGHT | WireCurrentTransfer.UP;
if (transferItem.isPowered() && transferItem.getTransfer() == transferType)
{
pointsToTrigger = wireSlower.RemoveWire(location.X, location.Y);
//form.Remove(location.X, location.Y);
}
else
{
pointsToTrigger = wireSlower.AddOrUpdateWire(location.X, location.Y, CurrentType.SENDER, WireCurrentTransfer.NONE);
//form.AddOrUpdateWire(location.X, location.Y, CurrentType.SENDER, WireCurrentTransfer.NONE);
}
HandleItems(pointsToTrigger, location);
}
public static WireTransferDto WrapToWireTransferDto(this WireTransfer wireTransfer)
{
return(new WireTransferDto
{
Id = Guid.Parse(wireTransfer.Id.Value.ToString()),
Sender = new SenderDto
{
Name = wireTransfer.SenderBankAccount.BankAccountHolder.HolderName,
Account = wireTransfer.SenderBankAccount.BankAccountDetails.Account,
Branch = wireTransfer.SenderBankAccount.BankAccountDetails.Branch,
Number = wireTransfer.SenderBankAccount.BankAccountDetails.Number,
Document = new DocumentDto
{
Number = wireTransfer.SenderBankAccount.BankAccountHolder.HolderDocument.Value,
Type = wireTransfer.SenderBankAccount.BankAccountHolder.HolderDocument.DocumentType.ToString()
}
},
Amount = wireTransfer.Amount.Value,
Protocol = new ProtocolDto
{
Code = wireTransfer.ProtocolTrackable.StatusCode,
Status = wireTransfer.ProtocolTrackable.StatusInformation,
Number = wireTransfer.ProtocolTrackable.ProtocolNumber
},
TradeDate = wireTransfer.TradeDate,
WireTransferType = ((int)wireTransfer.WireTransferType).ToString(),
Transaction = new TransactionDto
{
Id = Guid.Parse(wireTransfer.TransactionId.Value.ToString())
},
Account = new AccountDto
{
Id = Guid.Parse(wireTransfer.BeneficiaryBankAccount.BankAccountId.Value.ToString())
},
Beneficiary = null
});
}
public RegisterRejectedTransferNotification(WireTransfer wireTransfer,
BusinessRuleValidationException businessRuleValidationException)
{
WireTransfer = wireTransfer;
BusinessRuleValidationException = businessRuleValidationException;
}
