public ICommandResult Handle(AddAddressCommand command)
{
command.Validate();
if (command.Invalid)
{
AddNotifications(command);
return(new CommandResult(false, "Erro ao adicionar", Notifications));
}
var student = _studentRepository.GetById(command.StudentID);
var address = new Address
(
command.ZipCode,
command.Street,
command.Number,
command.Neighborhood,
command.City,
command.State,
command.PhoneNumber,
command.CellPhoneNumber
);
student.AddAddress(address);
AddNotifications(student, address);
if (Invalid)
{
return(new CommandResult(false, "Erro ao adicionar.", Notifications));
}
_studentRepository.AddAddress(student.Id, address);
return(new CommandResult(true, "Dados cadastrados com sucesso", Notifications));
}
/// <summary>
/// Add new Address
/// </summary>
/// <param name="addAddressCommand"></param>
/// <returns></returns>
public WithdrawAddressResponse AddAddress(AddAddressCommand addAddressCommand)
{
if (addAddressCommand.BitcoinAddress.Length < 26 || addAddressCommand.BitcoinAddress.Length > 34)
{
return(new WithdrawAddressResponse(false, "Invalid address"));
}
List <WithdrawAddress> withdrawAddresses = _withdrawAddressRepository.GetWithdrawAddressByAccountIdAndCurrency(
new AccountId(addAddressCommand.AccountId), new Currency(addAddressCommand.Currency));
foreach (var address in withdrawAddresses)
{
if (address.BitcoinAddress.Value == addAddressCommand.BitcoinAddress ||
address.Description == addAddressCommand.Description)
{
return(new WithdrawAddressResponse(false, "Duplicate Entry"));
}
}
// Create a new address and save in the database
WithdrawAddress withdrawAddress = new WithdrawAddress(new Currency(addAddressCommand.Currency),
new BitcoinAddress(addAddressCommand.BitcoinAddress), addAddressCommand.Description,
new AccountId(addAddressCommand.AccountId), DateTime.Now);
_fundsPersistenceRepository.SaveOrUpdate(withdrawAddress);
DepositAddress depositAddress = _depositAddressRepository.GetDepositAddressByAddress(new BitcoinAddress(addAddressCommand.BitcoinAddress));
if (depositAddress != null)
{
depositAddress.StatusUsed();
_fundsPersistenceRepository.SaveOrUpdate(depositAddress);
}
return(new WithdrawAddressResponse(true, "Address Saved"));
}
public void AddAddress_ClientDoesntExist_Exception(int _clientId)
{
DatabaseQueryProcessor.Erase();
Shared.FillTheDatabase();
var testSessionToken = SessionRepository.StartNewSession(_clientId);
var addAddressCommand = new AddAddressCommand
{
sessionToken = testSessionToken,
country = "Poland",
city = "Cracow",
street = "Urzednicza",
ZIPCode = 34040,
buildingNumber = 100,
apartmentNumber = ""
};
var handler = new AddAddressCommandHandler();
TestDelegate result = () => handler.Handle(addAddressCommand);
DatabaseQueryProcessor.Erase();
SessionRepository.RemoveSession(testSessionToken);
Assert.Throws <Exception>(result);
}
public void AddAddress_DuplicateAddress_Success(int _clientId, string _country, string _city, string _street, int _ZIPCode, int _buildingNumber, string _apartmentNumber)
{
DatabaseQueryProcessor.Erase();
Shared.FillTheDatabase();
var testSessionToken = SessionRepository.StartNewSession(_clientId);
var addressExists = DatabaseQueryProcessor.GetAddress(_clientId, _country, _city, _street, _ZIPCode, _buildingNumber, _apartmentNumber);
if (addressExists != null)
{
DatabaseQueryProcessor.UpdateAddress(addressExists.addressId, false);
}
var addAddressCommand = new AddAddressCommand
{
sessionToken = testSessionToken,
country = _country,
city = _city,
street = _street,
ZIPCode = _ZIPCode,
buildingNumber = _buildingNumber,
apartmentNumber = _apartmentNumber
};
var handler = new AddAddressCommandHandler();
var addressBook = (AddressBookDto)handler.Handle(addAddressCommand);
var record = DatabaseQueryProcessor.GetAddress(_clientId, _country, _city, _street, _ZIPCode, _buildingNumber, _apartmentNumber);
DatabaseQueryProcessor.Erase();
SessionRepository.RemoveSession(testSessionToken);
Assert.IsTrue(record.isActive);
}
public void AddAddress_AddNewAddress_Success(int _clientId, string _country, string _city, string _street, int _ZIPCode, int _buildingNumber, string _apartmentNumber)
{
DatabaseQueryProcessor.Erase();
Shared.FillTheDatabase();
var testSessionToken = SessionRepository.StartNewSession(_clientId);
var addAddressCommand = new AddAddressCommand
{
sessionToken = testSessionToken,
country = _country,
city = _city,
street = _street,
ZIPCode = _ZIPCode,
buildingNumber = _buildingNumber,
apartmentNumber = _apartmentNumber
};
var handler = new AddAddressCommandHandler();
var addressBook = (AddressBookDto)handler.Handle(addAddressCommand);
var record = DatabaseQueryProcessor.GetAddress(_clientId, _country, _city, _street, _ZIPCode, _buildingNumber, _apartmentNumber);
DatabaseQueryProcessor.Erase();
SessionRepository.RemoveSession(testSessionToken);
Assert.IsNotNull(record);
Assert.AreEqual(_clientId, record.clientId);
Assert.AreEqual(_country, record.country);
Assert.AreEqual(_city, record.city);
Assert.AreEqual(_street, record.street);
Assert.AreEqual(_ZIPCode, record.ZIPCode);
Assert.AreEqual(_buildingNumber, record.buildingNumber);
Assert.AreEqual(_apartmentNumber, record.apartmentNumber);
}
public void AddAddress()
{
var addAddressCommand = new AddAddressCommand(customer, address);
customerManager.SetCommand(addAddressCommand);
customerManager.ExecuteCommand();
}
public async Task OnPostAsync()
{
var addAddressCommand = new AddAddressCommand {
City = "VAN", PostalCode = "65000", StreetAddress = "Metmanis", UserId = 1
};
await Mediator.Send(addAddressCommand);
}
public async Task <ActionResult <Address> > CreateAddress(AddAddressCommand addAddressCommand)
{
try
{
Address address = await this.mediator.Send(addAddressCommand);
return(this.Ok(address));
}
catch (Exception ex)
{
return(this.BadRequest(ex));
}
}
public async Task <IActionResult> Index()
{
var addAddressCommand = new AddAddressCommand {
City = "VAN", PostalCode = "65000", StreetAddress = "Metmanis", UserId = 1
};
var response = await Mediator.Send(addAddressCommand);
Logger.LogInformation(response.Message);
await NotifierService.Notify("This is a notification service message");
return(View());
}
private void BuildAddAddressCommand()
{
_addAddressCommand = new AddAddressCommand()
{
StudentID = Guid.NewGuid(),
ZipCode = "80030001",
Street = "Av. João Gualberto",
Number = 1259,
Neighborhood = "Juvevê",
City = "Curitiba",
State = "PR",
PhoneNumber = "9885566622",
CellPhoneNumber = "988552244"
};
}
public async Task <IActionResult> AddAddress(long customerId, [FromBody] CreateAddressDto value)
{
var command = new AddAddressCommand(
customerId,
value.Street,
value.City,
value.ZipCode
);
var result = await messages.Dispatch(command);
return(result.Match <IActionResult>(
(errors) => BadRequest(errors),
(address) =>
{
var addressDto = mapper.Map <AddressDto>(address);
return Ok(addressDto);
}));
}
public async Task <IActionResult> Add([FromBody] AddAddressRequest addAddressRequest)
{
try
{
//request validation should be here
// ...
var command = new AddAddressCommand(addAddressRequest.Name, addAddressRequest.City, addAddressRequest.Street);
var result = await _mediator.Send(command);
return(CreatedAtAction(nameof(this.GetById), new { id = result.Id }));
}
catch (Exception e)
{
return(BadRequest(new ErrorResponse()
{
ShortInfo = e.Message, AdditionalInfo = e.StackTrace
}));
}
}
public void AddAddress_InvalidCountry_Exception(string _country)
{
var testSessionToken = SessionRepository.StartNewSession(0);
var addAddressCommand = new AddAddressCommand
{
sessionToken = testSessionToken,
country = _country,
city = "Wroclove",
street = "Mickiewicza",
ZIPCode = 30000,
buildingNumber = 12,
apartmentNumber = ""
};
var handler = new AddAddressCommandHandler();
TestDelegate result = () => handler.Handle(addAddressCommand);
SessionRepository.RemoveSession(testSessionToken);
Assert.Throws <Exception>(result);
}
public void ShouldUpdateCustomerWhenCommandIsValid()
{
var ad = new AddAddressCommand("Rua dona mariinha", "96", "Casa 2", "Santo Antonio", "Viçosa", "MG", "Brasil"
, "36570000", EAddressType.Shipping);
var ad2 = new AddAddressCommand("Rua dona mariinha", "96", "Casa 2", "Santo Antonio", "Viçosa", "MG", "Brasil"
, "36570000", EAddressType.Shipping);
var address = new List <AddAddressCommand>();
address.Add(ad);
address.Add(ad2);
var command = new UpdateCustomerCommand(Guid.NewGuid(), "Douglas", "Rocha", "09752725600", "*****@*****.**", "38914821", address);
var handler = new CustomerHandlers(new FakeCustomerRepository(), new FakeEmailService());
var result = handler.Handle(command);
Console.WriteLine(result);
Assert.AreNotEqual(false, result.Success);
Assert.AreEqual(true, handler.IsValid);
}
public ICommandResult Handle(AddAddressCommand command)
{
return(new AddAddressCommandResult());
}
public void AddAddress(AddAddressCommand command)
{
CommandBus.Dispatch(command);
}
public async Task <AddAddressCommandResponse> AddAddress([FromBody] AddAddressCommand address)
{
return(await _mediator.Send(address));
}
public ICommandResult Headle(AddAddressCommand command)
{
throw new System.NotImplementedException();
}
public ICommandResult Handle(AddAddressCommand command)
{
return(new CommandResult(true, "Sucesso", new { OK = true }));
}
public async Task <IActionResult> AddAddress(AddAddressCommand address)
{
address.CustomerId = _user.GetUserId();
return(CustomResponse(await _mediatorHandler.SendCommand(address)));
}
public ICommandResult AddAddress([FromBody] AddAddressCommand command)
{
return(_handler.Handle(command));
}
public ICommandResult Handle(AddAddressCommand command)
{
throw new NotImplementedException();
}
public void AddAddress(AddAddressCommand command)
{
customerCommandFacade.AddAddress(command);
}
