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")); }