public async Task Update(DepartureDto item) { var updItem = _mapper.Map <DepartureDto, Departure>(item); await _unitOfWork.Repository <Departure>().Update(updItem); await _unitOfWork.SaveAsync(); }
public void Update_When_departureDto_is_null_Then_throw_NullBodyException() { DepartureDto nullDto = null; int id = 1; Assert.Throws <NullBodyException>(() => _service.Update(id, nullDto)); }
public void Update_WhenDtoIsPassed_ThenReturnedTheSameWithPassedId() { // Arrange var id = Guid.NewGuid(); var crewId = Guid.NewGuid(); var airplaneId = Guid.NewGuid(); var dto = new DepartureDto() { Time = new DateTime(2018, 7, 17, 13, 0, 0), CrewId = crewId, AirplaneId = airplaneId }; A.CallTo(() => unitOfWorkFake.CrewRepositiry.Get(crewId)).Returns(new Crew { Id = crewId }); A.CallTo(() => unitOfWorkFake.AeroplaneRepository.Get(airplaneId)).Returns(new Aeroplane { Id = airplaneId }); var service = new DepartureService(unitOfWorkFake, mapper, alwaysValidValidator); // Act var returnedDto = service.Update(id, dto); // Assert Assert.True(returnedDto.Id != default(Guid)); Assert.AreEqual(dto.CrewId, returnedDto.CrewId); Assert.AreEqual(dto.AirplaneId, returnedDto.AirplaneId); Assert.AreEqual(dto.Time, returnedDto.Time); }
public void Update_Valid() { //arange DeparturesService service = new DeparturesService(unitOfWork, mapper, validator); var expected = new Departure { Id = 1, FlightId = 1, FlightNumber = "QW11", DepartureTime = Convert.ToDateTime("2018-07-13T08:22:56.6404304+03:00") }; var DtoToMake = new DepartureDto { Id = 1, FlightId = 1, FlightNumber = "QW11", DepartureTime = Convert.ToDateTime("2018-07-13T08:22:56.6404304+03:00") }; //act service.Update(DtoToMake); var actual = (unitOfWork.Set <Departure>() as FakeRpository <Departure>).updatedItem; //assert Assert.AreEqual(expected.Id, actual.Id); Assert.AreEqual(expected.FlightId, actual.FlightId); Assert.AreEqual(expected.FlightNumber, actual.FlightNumber); Assert.AreEqual(expected.DepartureTime, actual.DepartureTime); }
public async Task Create(DepartureDto item) { var newItem = _mapper.Map <DepartureDto, Departure>(item); await _unitOfWork.Repository <Departure>().Create(newItem); await _unitOfWork.SaveAsync(); }
public async Task <IActionResult> Post([FromBody] DepartureDto entity) { var result = await _departuresSrvice.AddAsync(entity); //if (result == null) return NotFound(); return(Ok(result)); }
public IActionResult Get(int id) { DepartureDto Departure = service.GetById(id); if (Departure == null) { return(NotFound()); } return(Ok(Departure)); }
public async Task <IActionResult> Get(int id) { DepartureDto Departure = await service.GetById(id); if (Departure == null) { return(NotFound()); } return(Ok(Departure)); }
public async Task <IActionResult> Put(int id, [FromBody] DepartureDto entity) { var result = await _departuresSrvice.UpdateAsync(entity, id); if (result == null) { return(NotFound()); } return(Ok(result)); }
public Departure MapDeparture(DepartureDto value) { return(new Departure { Id = value.ID, Date = value.Date, Crew = unitOfWork.Crew.Get(value.CrewId), Flight = unitOfWork.Flights.Get().SingleOrDefault(x => x.Number == value.Number), Plane = unitOfWork.Planes.Get(value.PlaneId) }); }
public IActionResult Delete([FromBody] DepartureDto departure) { try { service.Delete(departure); return(NoContent()); } catch (Exception ex) { return(NotFound(ex)); } }
public DepartureDto Update(Guid id, DepartureDto departureDto) { var departure = mapper.Map <DepartureDto, Departure>(departureDto); departure.Id = id; departure.Airplane = db.AeroplaneRepository.Get(departureDto.AirplaneId); departure.Crew = db.CrewRepositiry.Get(departureDto.CrewId); db.DepartureRepository.Update(departure); return(mapper.Map <Departure, DepartureDto>(departure)); }
public DepartureDto Create(DepartureDto departureDto) { var departure = mapper.Map <DepartureDto, Departure>(departureDto); departure.Id = Guid.NewGuid(); departure.Crew = db.CrewRepositiry.Get(departureDto.CrewId); departure.Airplane = db.AeroplaneRepository.Get(departureDto.AirplaneId); db.DepartureRepository.Create(departure); return(mapper.Map <Departure, DepartureDto>(departure)); }
public async Task <IActionResult> Post([FromBody] DepartureDto departureDto) { try { var departureToReturn = await _departureService.AddEntityAsync(departureDto); return(CreatedAtRoute("GetDeparture", new { id = departureToReturn.Id }, departureToReturn)); } catch (BadRequestException) { return(BadRequest()); } }
public void Create(DepartureDto departure) { var validationResult = validator.Validate(departure); if (validationResult.IsValid) { unit.Departures.Create(mapper.MapDeparture(departure)); } else { throw new ValidationException(validationResult.Errors); } }
public async Task <int> Create(DepartureDto departure) { var validationResult = validator.Validate(departure); if (validationResult.IsValid) { return(await unit.Departures.Create(await mapper.MapDeparture(departure))); } else { throw new ValidationException(validationResult.Errors); } }
public async Task <Departure> MapDeparture(DepartureDto value) { var list = await unitOfWork.Flights.Get(); return(new Departure { Id = value.ID, Date = value.Date, Crew = await unitOfWork.Crew.Get(value.Crew.ID), Flight = list.SingleOrDefault(x => x.Number == value.Flight.Number), Plane = await unitOfWork.Planes.Get(value.Plane.ID) }); }
public async Task <IActionResult> Update([FromBody] DepartureDto departure) { if (ModelState.IsValid) { await _service.Update(departure); return(Ok(departure)); } else { return(new BadRequestObjectResult(ModelState)); } }
public void Create_WhenDtoIsEmpty_ThenThrowValidExeption() { // Arrange var dto = new DepartureDto() { }; var service = new DepartureService(unitOfWorkFake, mapper, validator); // Act // Assert Assert.Throws <ValidationException>(() => service.Create(dto)); }
public IActionResult Post([FromBody] DepartureDto value) { try { service.Create(value); return(Ok()); } catch (ValidationException e) { return(BadRequest(e.Message)); } catch (Exception ex) { return(BadRequest(ex)); } }
public IActionResult Post([FromBody] DepartureDto dto) { try { var createdId = _departureService.Add(dto); return(CreatedAtAction("Get", _departureService.GetById(createdId))); } catch (ValidationException ex) { return(BadRequest(ex.Errors)); } catch (NullBodyException) { return(BadRequest()); } }
public void Create_When_DepartureModel_is_valid_Then_returns_id() { var flightService = new FlightService(unitOfWork, mapper, new FlightValidator()); var expectedDeparture = new DepartureDto() { Date = DateTime.Now, Number = flightService.Get(1).Number, CrewId = 1, PlaneId = 1 }; var id = service.Create(expectedDeparture); var actualDeparture = service.Get(id); Assert.AreEqual(expectedDeparture.Date, actualDeparture.Date); Assert.AreEqual(expectedDeparture.Number, actualDeparture.Number); }
public IActionResult Put(int id, [FromBody] DepartureDto Departure) { if (Departure == null) { ModelState.AddModelError("", "Не указаны данные для вылета"); return(BadRequest(ModelState)); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } service.Update(Departure); return(Ok(Departure)); }
public IActionResult Post([FromBody] DepartureDto Departure) { if (Departure == null) { ModelState.AddModelError("", "Не указаны данные для вылета"); return(BadRequest(ModelState)); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } service.Create(Departure); return(Created("api/Departures", Departure)); }
public void Update_UnValid() { //arange DeparturesService service = new DeparturesService(unitOfWork, mapper, validator); var DtoToMake = new DepartureDto { Id = 1, FlightId = 1, FlightNumber = "1", DepartureTime = Convert.ToDateTime("2018-07-13T08:22:56.6404304+03:00") }; //act service.Update(DtoToMake); var actual = (unitOfWork.Set <Departure>() as FakeRpository <Departure>).updatedItem; //assert Assert.IsNull(actual); }
public async Task <IActionResult> Put(Guid id, [FromBody] DepartureDto departureDto) { try { departureDto.Id = id; await _departureService.UpdateEntityAsync(departureDto); return(NoContent()); } catch (BadRequestException) { return(BadRequest()); } catch (NotFoundException) { return(NotFound()); } }
public async Task <Departure> CreateOrUpdate(Guid?departureId, DepartureDto createdDepartureData) { Departure departure; if (departureId.HasValue) { await _departureRepository.UpdateAsync(departureId.Value, createdDepartureData); departure = await _departureRepository.GetAsync(departureId.Value); } else { departure = _departureRepository.Add(createdDepartureData); } await _domainContext.SaveChangesAsync(); return(departure); }
public void Update_When_departureModel_is_valid_and_id_is_exist_Then_call_Update_method() { var validDto = new DepartureDto { Airplane = new Airplane { Name = "Airflot", ExploitationTerm = TimeSpan.FromDays(1000), ReleaseDate = new DateTime(1970, 5, 21), Type = new AirplaneType { AirplaneModel = "YZ-222", CarryingCapacity = 14000, SeatsCount = 987 } }, Crew = new Crew { Pilot = new Pilot { FirstName = "Petro", LastName = "Boroda", Birthdate = new DateTime(1989, 10, 12), Experience = 4 }, Stewardesses = new List <Stewardesse> { new Stewardesse { FirstName = "Maria", LastName = "Alexandrovna", Birthdate = new DateTime(1990, 3, 1) } } }, DepartureTime = new DateTime(2018, 07, 16, 20, 21, 0), FlightNumber = "YM-2343" }; int existId = 3; _service.Update(existId, validDto); A.CallTo(() => _repository.Update(A <int> ._, A <Departure> ._)).MustHaveHappened(); }
public IActionResult Put(Guid id, [FromBody] DepartureDto departureDto) { if (!ModelState.IsValid) { return(BadRequest(new { Type = "ValidationError", ErrorMessage = "Required fields is empty" })); } DepartureDto resultDto; try { resultDto = departureService.Update(id, departureDto); } catch (Exception ex) { return(BadRequest(new { ErrorType = ex.GetType().Name, ex.Message })); } return(Ok(resultDto)); }
public IActionResult Put(int id, [FromBody] DepartureDto dto) { try { _departureService.Update(id, dto); return(Ok()); } catch (NotExistException) { return(NotFound()); } catch (ValidationException ex) { return(BadRequest(ex.Errors)); } catch (NullBodyException) { return(BadRequest()); } }