Пример #1
0
        public async Task UpdateEntityAsync(int id, DepartureDTO departureDTO)
        {
            var departure = await departureRepository.GetAsync(id);

            if (departure == null)
            {
                throw new ValidationException($"Departure with this id {id} not found");
            }

            if (departureDTO.FlightNumber > 0)
            {
                departure.FlightNumber = departureDTO.FlightNumber;
            }
            if (departureDTO.CrewId > 0)
            {
                departure.CrewId = departureDTO.CrewId;
            }
            if (departureDTO.FlightId > 0)
            {
                departure.FlightId = departureDTO.FlightId;
            }
            if (departureDTO.PlaneId > 0)
            {
                departure.PlaneId = departureDTO.PlaneId;
            }
            if (departureDTO.Time != DateTime.MinValue)
            {
                departure.Time = departureDTO.Time;
            }

            await departureRepository.UpdateAsync(departure).ConfigureAwait(false);
        }
Пример #2
0
        [Test] // behaviour test
        public void Create_When_entity_is_created_Then_it_makes_calls_to_repository_and_unit_of_work()
        {
            // Arrange
            var departureDTOToCreate = new DepartureDTO()
            {
                Date     = new DateTime(2018, 10, 1),
                FlightId = 1,
                PlaneId  = 1,
                CrewId   = 1
            };

            var departureRepositoryFake = A.Fake <IDepartureRepository>();

            var unitOfWorkFake = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWorkFake.Set <Departure>()).Returns(departureRepositoryFake);

            var departureService = new DepartureService(unitOfWorkFake, AlwaysValidValidator);

            // Act
            var result = departureService.Create(departureDTOToCreate);

            // Assert. Just behaviour
            A.CallTo(() => departureRepositoryFake.Create(A <Departure> ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => unitOfWorkFake.Set <Departure>()).MustHaveHappenedOnceExactly();
            A.CallTo(() => unitOfWorkFake.SaveChanges()).MustHaveHappenedOnceExactly();
        }
Пример #3
0
        public void Create_When_entity_is_invalid_Then_bad_request_exception_is_thrown()
        {
            // Arrange
            var departureMock = new Departure()
            {
                Id       = 2,
                Date     = new DateTime(2018, 10, 1),
                FlightId = 2,
                PlaneId  = 2,
                CrewId   = 2
            };

            var departureDTOToCreate = new DepartureDTO()
            {
                Date     = new DateTime(2018, 10, 1),
                FlightId = 2,
                PlaneId  = 2,
                CrewId   = 2
            };

            var departureRepositoryFake = A.Fake <IDepartureRepository>();

            A.CallTo(() => departureRepositoryFake.Create(A <Departure> ._)).Returns(departureMock);

            var unitOfWorkFake = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWorkFake.Set <Departure>()).Returns(departureRepositoryFake);

            var departureService = new DepartureService(unitOfWorkFake, AlwaysInValidValidator);

            // Act + Assert
            var exception = Assert.Throws <BadRequestException>(() => departureService.Create(departureDTOToCreate), "");

            Assert.AreEqual(exception.Message, "Is Invalid");
        }
        public DepartureDTO AddDeparture(DepartureDTO departure)
        {
            Validation(departure);
            Departure modelDeparture = mapper.Map <DepartureDTO, Departure>(departure);

            return(mapper.Map <Departure, DepartureDTO>(unitOfWork.Departures.Create(modelDeparture)));
        }
Пример #5
0
        public void CreateEntity_Should_Create_departure_typeof_Departure()
        {
            // Arrange
            DepartureDTO departureDTO = new DepartureDTO
            {
                Id           = 1,
                CrewId       = 1,
                FlightId     = 1,
                FlightNumber = 1111,
                PlaneId      = 1,
                Time         = new DateTime(2018, 07, 12)
            };
            Departure departure = new Departure
            {
                Id           = 1,
                CrewId       = 1,
                FlightId     = 1,
                FlightNumber = 1111,
                PlaneId      = 1,
                Time         = new DateTime(2018, 07, 12)
            };

            var departureRepository = new FakeRepository <Departure>();
            var departureService    = new DepartureService(departureRepository);

            // Act
            departureService.CreateEntity(departureDTO);
            var result = departureRepository.Get(1);

            // Assert
            Assert.AreEqual(departure, result);
        }
        public void UpdateEntity(int id, DepartureDTO departureDTO)
        {
            var departure = departureRepository.Get(departureDTO.Id);

            if (departure == null)
            {
                throw new ValidationException($"Departure with this id {departureDTO.Id} not found");
            }

            if (departureDTO.FlightNumber > 0)
            {
                departure.FlightNumber = departureDTO.FlightNumber;
            }
            if (departureDTO.CrewId > 0)
            {
                departure.CrewId = departureDTO.CrewId;
            }
            if (departureDTO.PlaneId > 0)
            {
                departure.PlaneId = departureDTO.PlaneId;
            }
            if (departureDTO.Time != DateTime.MinValue)
            {
                departure.Time = departureDTO.Time;
            }

            departureRepository.Update();
        }
Пример #7
0
 public void Post([FromBody] DepartureDTO value)
 {
     if (ModelState.IsValid)
     {
         Service.Create(value);
     }
 }
Пример #8
0
        private void Create_Click(object sender, RoutedEventArgs e)
        {
            var turple    = RenderCreate();
            var btnCreate = turple.Item1;
            var number    = turple.Item2;
            var time      = turple.Item3;
            var planes    = turple.Item4;
            var crews     = turple.Item5;

            btnCreate.Click += async(object sen, RoutedEventArgs evArgs) =>
            {
                var plane = new DepartureDTO()
                {
                    FlightNumber = number.Text, DepartureTime = (new DateTime(2018, 2, 2) + time.Time).ToString(),
                    PlaneId      = ((PlaneDTO)planes.SelectedItem).Id, CrewId = ((CrewDTO)crews.SelectedItem).Id
                };
                try
                {
                    await service.CreateAsync(plane);
                }
                catch (Exception) { }

                departuresList.Add(plane);
                UpdateList();
                SingleItem.Children.Clear();
            };
        }
Пример #9
0
        [Test] // behaviour test
        public void Create_When_entity_is_invalid_Then_it_makes_no_calls_to_repository_and_unit_of_work()
        {
            // Arrange
            var departureDTOToCreate = new DepartureDTO()
            {
                Date     = new DateTime(2018, 10, 1),
                FlightId = 2,
                PlaneId  = 2,
                CrewId   = 2
            };

            var departureRepositoryFake = A.Fake <IDepartureRepository>();

            var unitOfWorkFake = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWorkFake.Set <Departure>()).Returns(departureRepositoryFake);

            var departureService = new DepartureService(unitOfWorkFake, AlwaysInValidValidator);

            // Act + Assert
            var exception = Assert.Throws <BadRequestException>(() => departureService.Create(departureDTOToCreate));

            // Assert. Just behaviour
            A.CallTo(() => departureRepositoryFake.Create(A <Departure> ._)).MustNotHaveHappened();
            A.CallTo(() => unitOfWorkFake.DepartureRepository).MustNotHaveHappened();
            A.CallTo(() => unitOfWorkFake.Set <Departure>()).MustNotHaveHappened();
            A.CallTo(() => unitOfWorkFake.SaveChanges()).MustNotHaveHappened();
        }
Пример #10
0
        public async Task <IActionResult> Update(int id, [FromBody] DepartureDTO item)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            try
            {
                item.Id = id;
                await service.GetById(id);

                await service.Update(item);

                await service.SaveChanges();

                return(Ok(item));
            }
            catch (NotFoundException e)
            {
                return(NotFound(e.Message));
            }
            catch (Exception)
            {
                return(BadRequest());
            }
        }
Пример #11
0
        private bool ValidateBetweenDaysDepartureRun(IEnumerable <DepartureDTO> departureRun)
        {
            DepartureDTO previousDeparture = null;
            bool         haveAlreadyBeenOneDepartureBetweenDays = false;

            foreach (var departure in departureRun)
            {
                if (previousDeparture != null)
                {
                    if (previousDeparture.DepartureTime == departure.DepartureTime)
                    {
                        throw new ArgumentException(ValidationResources.DeparturesTimesCantBeEqual);
                    }
                    if (previousDeparture.DepartureTime > departure.DepartureTime)
                    {
                        if (haveAlreadyBeenOneDepartureBetweenDays == true)
                        {
                            throw new ArgumentException(ValidationResources.DeparturesTimesNotCorrectOnBetweenDays);
                        }
                        else
                        {
                            haveAlreadyBeenOneDepartureBetweenDays = true;
                        }
                    }
                }
                previousDeparture = departure;
            }
            if (haveAlreadyBeenOneDepartureBetweenDays == false)
            {
                throw new ArgumentException(ValidationResources.BetweenDaysNotShouldBeChecked);
            }
            return(true);
        }
 public void Put(int id, [FromBody] DepartureDTO departure)
 {
     if (ModelState.IsValid)
     {
         service.Update(id, departure);
     }
 }
 public void Post([FromBody] DepartureDTO departure)
 {
     if (ModelState.IsValid)
     {
         service.Create(departure);
     }
 }
Пример #14
0
 private IEnumerable <DepartureDTO> CorrectRun(IEnumerable <DepartureDTO> departureRun)
 {
     if (ShoulRunBeCorrected(departureRun))
     {
         DepartureDTO lastDeparture    = null;
         departureRun.Last().IsNextDay = true;
         bool shouldRestBeOnNextDay    = false;
         foreach (var departure in departureRun)
         {
             if (lastDeparture != null)
             {
                 if (!shouldRestBeOnNextDay)
                 {
                     if (lastDeparture.DepartureTime < departure.DepartureTime)
                     {
                         lastDeparture.IsNextDay = false;
                     }
                     else
                     {
                         lastDeparture.IsNextDay     = false;
                         lastDeparture.IsBetweenDays = true;
                         shouldRestBeOnNextDay       = true;
                     }
                 }
                 else
                 {
                     lastDeparture.IsNextDay = true;
                 }
             }
             lastDeparture = departure;
         }
     }
     return(departureRun);
 }
        public async Task Update(int id, DepartureDTO modelDTO)
        {
            var source = uow.Departures.Get(id);
            var dest   = mapper.Map <DepartureDTO, Departure>(modelDTO);
            await uow.Departures.Update(dest);

            await uow.SaveAsync();
        }
Пример #16
0
 public void UpdateDeparture(DepartureDTO departure)
 {
     if (departure != null)
     {
         Departure updatedDepart = mapper.Map <DepartureDTO, Departure>(departure);
         unitOfWork.DepartureRepository.Insert(updatedDepart);
     }
 }
        private void Validation(DepartureDTO departure)
        {
            var validationResult = validator.Validate(departure);

            if (!validationResult.IsValid)
            {
                throw new Exception(validationResult.Errors.First().ToString());
            }
        }
Пример #18
0
        public async Task <IActionResult> Get(int id)
        {
            DepartureDTO ticket = await service.GetById(id);

            if (ticket == null)
            {
                return(NotFound());
            }
            return(Ok(ticket));
        }
 private Departure ConvertToModel(DepartureDTO departureDTO)
 {
     if (departureDTO != null)
     {
         return(new Departure {
             DepartureId = departureDTO.DepartureId, PlaneNumber = departureDTO.PlaneNumber, Time = departureDTO.Time
         });
     }
     return(null);
 }
        public async Task <DepartureDTO> AddDeparture(DepartureDTO departure)
        {
            Validation(departure);
            Departure modelDeparture = mapper.Map <DepartureDTO, Departure>(departure);
            Departure result         = await unitOfWork.Departures.Create(modelDeparture);

            await unitOfWork.SaveChangesAsync();

            return(mapper.Map <Departure, DepartureDTO>(result));
        }
Пример #21
0
        public IActionResult ModifyDeparture(long id, [FromBody] DepartureDTO departure)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest() as IActionResult);
            }
            var entity = service.ModifyDeparture(id, mapper.Map <Departure>(departure));

            return(entity == null?StatusCode(304) as IActionResult
                   : Ok(mapper.Map <DepartureDTO>(entity)));
        }
Пример #22
0
 public void UpdateDeparture(DepartureDTO departure)
 {
     if (departure != null)
     {
         Departure updatedDepart = mapper.Map <DepartureDTO, Departure>(departure);
         unit.DeparturesRepo.Update(updatedDepart);
     }
     else
     {
         throw new ArgumentNullException();
     }
 }
 public HttpResponseMessage Put(int id, [FromBody] DepartureDTO departure)
 {
     if (ModelState.IsValid && departure != null)
     {
         _service.Update <Departure>(id, Mapper.Map <DepartureDTO, Departure>(departure));
         return(new HttpResponseMessage(HttpStatusCode.OK));
     }
     else
     {
         return(new HttpResponseMessage(HttpStatusCode.BadRequest));
     }
 }
Пример #24
0
 public JsonResult Put(int id, [FromBody] DepartureDTO departure)
 {
     try
     {
         return(Json(departureService.UpdateDeparture(id, departure)));
     }
     catch (System.Exception ex)
     {
         HttpContext.Response.StatusCode = 404;
         return(Json(ex.Message));
     }
 }
Пример #25
0
 public JsonResult Post([FromBody] DepartureDTO departure)
 {
     try
     {
         return(Json(departureService.AddDeparture(departure)));
     }
     catch (System.Exception ex)
     {
         HttpContext.Response.StatusCode = 400;
         return(Json(ex.Message));
     }
 }
Пример #26
0
        public IActionResult Post([FromBody] DepartureDTO value)
        {
            var validationResult = _depatureModelValidator.Validate(value);

            if (!validationResult.IsValid)
            {
                throw new BadRequestException(validationResult.Errors);
            }

            var entity = _departureService.Create(value);

            return(Json(entity));
        }
Пример #27
0
        public static Departure Mapp(DepartureDTO entity, IUnitOfWork data)
        {
            var crews     = data.Set <Crew>().Get();
            var airplanes = data.Set <Airplane>().Get();

            Mapper.Initialize(cfg => cfg.CreateMap <DepartureDTO, Departure>()
                              .ForMember("Crew", opt => opt.MapFrom(c => crews.FirstOrDefault(a => a.Id == c.CrewId)))
                              .ForMember("Airplane", opt => opt.MapFrom(c => airplanes.FirstOrDefault(a => a.Id == c.AirplaneId))));

            var res = Mapper.Map <DepartureDTO, Departure>(entity);

            return(res);
        }
Пример #28
0
 public void CreateDeparture(DepartureDTO departure)
 {
     if (departure != null)
     {
         Departure newDepart = mapper.Map <DepartureDTO, Departure>(departure);
         unit.DeparturesRepo.Insert(newDepart);
         unit.SaveChanges();
     }
     else
     {
         throw new ArgumentNullException();
     }
 }
Пример #29
0
 public HttpResponseMessage Post([FromBody] DepartureDTO departure)
 {
     if (ModelState.IsValid && departure != null)
     {
         _service.Post <Departure>(Mapper.Map <DepartureDTO, Departure>(departure));
         _service.SaveChanges();
         return(new HttpResponseMessage(HttpStatusCode.OK));
     }
     else
     {
         return(new HttpResponseMessage(HttpStatusCode.BadRequest));
     }
 }
Пример #30
0
        public void AddDeparture_When_IdAircraft_empty_Then_throws_exception()
        {
            //assign
            DepartureDTO departure = new DepartureDTO()
            {
                FlightNumber  = 1,
                DepartureTime = new DateTime(2018, 2, 2),
                IdCrew        = 1
            };

            //assert
            Assert.ThrowsAsync <Exception>(async() => await departureService.AddDeparture(departure));
        }