public void AddAddress(Address address)
{
address.LastModifiedDateUtc = DateTime.UtcNow;
address.CreatedDateUtc = DateTime.UtcNow;
address.LastModifiedBy = 1;
_repository.Create(address);
}
public ActionResult Post([FromBody] CreatePersonDto personDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var personWithoutAddress = _mapper.Map <PersonWithoutAddressDto>(personDto);
var personEntity = _mapper.Map <Person>(personWithoutAddress);
_personRepository.Add(personEntity);
if (!_personRepository.Save())
{
return(StatusCode(500, "An error occured while making the change"));
}
foreach (var address in personDto.Addresses)
{
address.PersonID = personEntity.ID;
var addressEntity = _mapper.Map <Address>(address);
_addressRepository.Create(addressEntity);
if (!_addressRepository.Save())
{
return(StatusCode(500, "An error occured while making the change"));
}
}
return(CreatedAtAction("Post", new { id = personEntity.ID }, personEntity));
}
public async Task <IActionResult> Create([FromBody] AddressCreateDTO addressDTO)
{
var location = GetCotrollerActionNames();
try
{
if (addressDTO == null)
{
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var address = _mapper.Map <Address>(addressDTO);
var exists = await _clientRepository.IsExist(addressDTO.ClientId);
if (!exists)
{
return(BadRequest("Client not found!"));
}
await _addressRepository.Create(address);
return(Created("Create", new { address }));
}
catch (Exception e)
{
return(InternalServerError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public async Task <IActionResult> UpdateRestaurantDetails(string id, [FromBody] RestaurantDetailsModel detailsModel)
{
var details = await _restaurantDetailsRepository.GetRestaurantDetails();
details.OpeningHour = detailsModel.OpeningHour;
details.ClosingHour = detailsModel.ClosingHour;
details.Details = detailsModel.Details;
if (details.Address == null)
{
var address = new Address()
{
Id = Guid.NewGuid(),
Name = "RestaurantDetails",
City = await _cityRepository.GetById(detailsModel.Address.City.Id),
Country = await _countryRepository.GetById(detailsModel.Address.Country.Id),
Street = detailsModel.Address.Street,
};
_addressRepository.Create(address);
details.Address = address;
}
else
{
details.Address.Name = detailsModel.Address.Name;
details.Address.City = await _cityRepository.GetById(detailsModel.Address.City.Id);
details.Address.Country = await _countryRepository.GetById(detailsModel.Address.Country.Id);
details.Address.Street = detailsModel.Address.Street;
}
_restaurantDetailsRepository.Update(details);
return(Ok(new { restaurantDetails = details }));
}
public Address Create(object createAddressViewModel)
{
var model = (CreateAddressViewModel)createAddressViewModel;
var address =
new Address(
description: model.Description,
zipCode: model.ZipCode,
type: (AddressType)model.Type,
street: model.Street,
neighborhood: model.Neighborhood,
number: model.Number,
city: model.City,
state: model.State,
customerId: Guid.Parse(model.CustomerId));
if (!address.Valid)
{
return(address);
}
address.SetCodeCity(codeCity: model.CodeCity);
_addressRepository.Create(address);
_uow.Commit();
return(address);
}
public async Task CreateAddressAsync(Address item)
{
item.id = await Repository.GetNextId();
Repository.Create(item);
await Repository.SaveAsync();
}
public IActionResult Post([FromBody] Models.Address value)
{
try
{
bool dt = Address.Create(value);
var reval = dt ? StatusCode(StatusCodes.Status200OK) : StatusCode(StatusCodes.Status204NoContent);
return(reval);
}
catch (Helper.RepositoryException ex)
{
switch (ex.Type)
{
case UpdateResultType.SQLERROR:
return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error"));
case UpdateResultType.INVALIDEARGUMENT:
return(StatusCode(StatusCodes.Status409Conflict, "Conflict"));
case UpdateResultType.ERROR:
return(StatusCode(StatusCodes.Status400BadRequest, "Bad Request"));
default:
return(StatusCode(StatusCodes.Status406NotAcceptable, "Not Acceptable"));
}
}
}
public async Task WhenThereIsAnException_ShouldReturnInternalServerError()
{
_addressRepository.Create(null).ThrowsForAnyArgs(new Exception());
var response = await _handler.Handle(_command, CancellationToken.None);
response.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
response.IsFailure.Should().BeTrue();
}
public IHttpActionResult Post([FromBody] Address entity)
{
logger.Trace("Call AddressController Post");
var record = AddressRepository.Create(entity);
return(Created(record));
}
[HttpPost()] //Create
public IActionResult Add([FromBody] Address value)
{
try
{
if (value.Id != 0)
{
return(StatusCode(StatusCodes.Status406NotAcceptable));
}
List <Address> AddressList = _AddressRepo.Create(value);
if (AddressList == null)
{
return(StatusCode(StatusCodes.Status206PartialContent));
}
else if (AddressList != null)
{
return(StatusCode(StatusCodes.Status201Created, AddressList));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
catch (Helper.RepoException ex)
{
switch (ex.Type)
{
case EnumResultTypes.INVALIDARGUMENT:
return(StatusCode(StatusCodes.Status400BadRequest));
case EnumResultTypes.NOTFOUND:
return(StatusCode(StatusCodes.Status204NoContent));
case EnumResultTypes.SQLERROR:
return(StatusCode(StatusCodes.Status408RequestTimeout));
case EnumResultTypes.ERROR:
return(StatusCode(StatusCodes.Status500InternalServerError));
default:
return(StatusCode(StatusCodes.Status501NotImplemented));
}
}
catch (Exception ex)
{
var logObj2 = new ExceptionData(ex);
logObj2.CustomNumber = 123;
logObj2.CustomText = "abs";
logObj2.Add("start_time", DateTime.UtcNow);
logObj2.Add("myObject", new
{
TappId = 15,
Name = "Sebastian"
});
_logger.Error(logObj2);
return(StatusCode(StatusCodes.Status501NotImplemented));
}
}
public async Task Create(Person personToSave, Address addressToSave, Email emailToSave, Phone phoneNumberToSave,
Personal personalToSave)
{
await _context.Persons.AddAsync(personToSave);
await _context.SaveChangesAsync();
addressToSave.PersonId = personToSave.Id;
await _addressRepository.Create(addressToSave);
emailToSave.PersonId = personToSave.Id;
await _emailRepository.Create(emailToSave);
personalToSave.PersonId = personToSave.Id;
await _personalRepository.Create(personalToSave);
phoneNumberToSave.PersonId = personToSave.Id;
await _phoneRepository.Create(phoneNumberToSave);
}
public IActionResult Post([FromBody] Address address)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_db.Create(address);
return(Ok(address));
}
public Address Create(CreateAddressCommand command)
{
var Address = new Address(command.CEP, command.State, command.City, command.Street, command.Number, command.Type, command.Description);
Address.Validate();
_repository.Create(Address);
if (Commit())
{
return(Address);
}
return(null);
}
private int InsertAddresReturnID(RetnsViewModels rentV, int cityDropDown)
{
var address = new Addres()
{
City_ID = cityDropDown,
District_ID = rentV.District_ID,
Flat = rentV.Flat,
Street = rentV.Street
};
_addressRep.Create(address);
_addressRep.Save();
return(address.Addres_ID);;
}
public void TestAddress_Create()
{
var address = new Address
{
AnotherId = "Another ID",
PersonId = 1,
Line1 = "Address Line 1",
PostCode = "Post Code"
};
var expected = true;
var actual = _repository.Create(address);
Assert.IsTrue(actual == expected, $"expected: {expected}, but received: {actual}");
Assert.IsTrue(_repository.GetAll().Count() == 11);
}
public ActionResult Post([FromBody] AddressCreateDto addressDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var addressEntity = _mapper.Map <Address>(addressDto);
_addressRepository.Create(addressEntity);
if (!_personRepository.Save())
{
return(StatusCode(500, "An error occured while making the change"));
}
return(CreatedAtAction("Post", new { id = addressEntity.ID }, addressEntity));
}
public async Task <Response> Handle(CreateUserAddressCommand request, CancellationToken cancellationToken)
{
try
{
var address = new Address(request.UserId, request.StreetName, request.StreetNumber, request.Complement,
request.Cep, request.City, request.State, request.Name);
await _addressRepository.Create(address);
await _mediator.Dispatch(address.DomainEvents, cancellationToken);
return(Response.Ok(HttpStatusCode.Created));
}
catch (Exception ex)
{
_logger.LogError(ex, "Erro ao cadastrar usuário");
return(Response.Fail(HttpStatusCode.InternalServerError, "Erro ao cadastrar usuário"));
}
}
public OutputDtoQueryAddress Create(InputDtoAddAddress address)
{
var addressFromDb = _addressRepository.Create(new Address
{
Street = address.Street,
HomeNumber = address.HomeNumber,
Zip = address.Zip,
City = address.City
});
return(new OutputDtoQueryAddress
{
Id = addressFromDb.Id,
Street = addressFromDb.Street,
HomeNumber = addressFromDb.HomeNumber,
Zip = addressFromDb.Zip,
City = addressFromDb.City
});
}
public ActionResult Create([Bind(Include = "Id,PostCode,City,Street,BuildingNr")] Address address)
{
var validator = new AddressValidator();
var result = validator.Validate(address);
if (result.IsValid)
{
_addressRepository.Create(address);
return(RedirectToAction("Index"));
}
ModelState.Clear();
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.ErrorMessage);
}
return(View(address));
}
/// <summary>
/// Método de execução de comando.
/// </summary>
/// <param name="personKey">Chave da pessoa</param>
/// <returns>Endereço criado.</returns>
public async Task <CreateAddressViewModel> Execute(Guid personKey)
{
var address = new Address
{
Key = Guid.NewGuid(),
Number = Model.Number,
PersonKey = personKey,
Street = Model.Street
};
await _repository.Create(address);
return(new CreateAddressViewModel
{
Key = address.Key,
Number = address.Number,
PersonKey = address.PersonKey,
Street = address.Street
});
}
public async Task <DomainValidationResult <Address> > AddAddressAsync(
UserId userId,
Country country,
string line1,
string?line2,
string city,
string?state,
string?postalCode
)
{
var result = new DomainValidationResult <Address>();
var addressBookLimit = Options.Static.AddressBook.Limit;
if (await _addressRepository.AddressCountAsync(userId) >= addressBookLimit)
{
result.AddFailedPreconditionError($"You can have a maximum of {addressBookLimit} addresses in your address book");
}
if (result.IsValid)
{
var address = new Address(
userId,
country,
line1,
line2,
city,
state,
postalCode);
_addressRepository.Create(address);
await _addressRepository.UnitOfWork.CommitAsync();
await _serviceBusPublisher.PublishUserAddressChangedIntegrationEventAsync(userId, address);
return(address);
}
return(result);
}
public async Task <IActionResult> Post([FromBody] AddressForCreationDto addressForCreationDto)
{
if (await this._customerRepo.GetSingle(addressForCreationDto.CustomerId) == null)
{
return(BadRequest());
}
var address = new Address
{
AddressLine1 = addressForCreationDto.AddressLine1,
AddressLine2 = addressForCreationDto.AddressLine2,
Street = addressForCreationDto.Street,
Town = addressForCreationDto.Town,
Postcode = addressForCreationDto.Postcode,
CustomerId = addressForCreationDto.CustomerId
};
await _addressRepo.Create(address);
return(Ok(addressForCreationDto));
}
public async Task <IActionResult> CreateAddress(AddressCreationDto dto)
{
var newAddress = new AddressCreationDto
{
Street = dto.Street,
Number = dto.Number,
Floor = dto.Floor,
Departament = dto.Departament,
House = dto.House,
Lot = dto.Lot,
Apple = dto.Apple,
Neighborhood = dto.Neighborhood,
PostalCode = dto.PostalCode,
Observation = dto.Observation,
LocationId = dto.LocationId,
PersonId = dto.PersonId
};
await _addressRepository.Create(newAddress);
return(Ok(dto));
}
public ActionResult Create(ClientViewModels clientV, int?cityDropDown)
{
try
{
var address = new Addres()
{
City_ID = cityDropDown,
District_ID = clientV.District_ID,
Flat = clientV.Flat,
Street = clientV.Street
};
_addressRep.Create(address);
_addressRep.Save();
var addressId = address.Addres_ID;
var client = new Client()
{
Name = clientV.Name,
Surname = clientV.Surname,
Email = clientV.Email,
Idnp = clientV.Idnp,
Phone = clientV.Phone,
Addres_ID = addressId,
};
_clientRep.Create(client);
_clientRep.Save();
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View(e));
}
}
public Address Create(Address value)
{
return(_addressRepository.Create(value));
}
public async Task CreateAddress(Address address) => await _addressRepository.Create(address);
public Address Create(Address address)
{
_addressValidator.DefaultValidation(address);
return(_addressRepository.Create(address));
}
public async Task <bool> Create(Address address) => await _addressRepository.Create(address);
public Address Create(Address Address)
{
return(AddressRepo.Create(Address));
}
public IActionResult Create(AddressViewModel addressViewModel)
{
_addressRepository.Create(addressViewModel.Address);
return(RedirectToAction("Index"));
}
