Пример #1
0
        public ActionResult Delete(int id)
        {
            var rezervasyon = _reservationManager.Find(i => i.Id == id);

            _reservationManager.Delete(rezervasyon);
            return(RedirectToAction("Index", "Reservation"));
        }
 private void DeleteReservation(Reservation reservation)
 {
     if (reservation != default(Reservation) && MessageBox.Show("Wollen Sie diese Reservation wirklich löschen?", "Löschen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
     {
         try
         {
             resManager.Delete(reservation);
             Reservationen.Remove(reservation);
         }
         catch (DatabaseChangeException)
         {
             displayer.DisplayError("Fehler beim Löschen", "Der Eintrag konnte nicht aus der Datenbank gelöscht werden!");
         }
         catch (OptimisticConcurrencyException <Auto> )
         {
             displayer.DisplayError("Fehler beim Löschen", "Es ist ein Nebenläufigkeitsproblem aufgetreten. Bitte versuchen Sie es erneut.");
         }
         catch (EntityNotFoundException)
         {
             Reservationen.Remove(reservation);
             displayer.DisplayError("Fehler beim Löschen", "Der zu löschende Eintrag existiert nicht in der Datenbank.");
         }
         Empty = Reservationen.Count == 0;
     }
 }
Пример #3
0
        public override async Task <Empty> Delete(ReservationDto request, ServerCallContext context)
        {
            ReservationManager manager     = new ReservationManager();
            Reservation        reservation = request.ConvertToEntity();
            await manager.Delete(reservation);

            return(new Empty());
        }
Пример #4
0
        public override async Task <Empty> DeleteReservation(ReservationDto request, ServerCallContext context)
        {
            Reservation reservation = request.ConvertToEntity();

            await _reservationManager.Delete(reservation);

            Empty empt = new Empty();

            return(empt);
        }
        public async Task DeleteReservationTest()
        {
            // arrange
            Reservation = await _target.Get(1);

            // act
            await _target.Delete(Reservation);

            var ex = await Assert.ThrowsAsync <KeyNotFoundException>(async() =>
                                                                     await _target.Get(Reservation.ReservationNr)
                                                                     );
        }
 public void DeleteReservation(ReservationDto reservationToBeDeleteed)
 {
     WriteActualMethod();
     try { reservationManager.Delete(reservationToBeDeleteed.ConvertToEntity()); }
     catch (OptimisticConcurrencyException <Reservation> )
     {
         OptimisticConcurrencyFault ocf = new OptimisticConcurrencyFault
         {
             Operation   = "Delete",
             ProblemType = "Optimstic Cocurrency Error during deleting on Reservation!"
         };
         throw new FaultException <OptimisticConcurrencyFault>(ocf);
     }
 }
Пример #7
0
        public override async Task <Empty> Delete(ReservationDto request, ServerCallContext context)
        {
            try
            {
                ReservationManager manager = new ReservationManager();
                await manager.Delete(request.ConvertToEntity());

                return(new Empty());
            }
            catch (OptimisticConcurrencyException <Reservation> e)
            {
                throw new RpcException(new Status(StatusCode.Aborted, e.Message));
            }
        }
Пример #8
0
        public ActionResult Delete(int id)
        {
            Car car = carManager.Find(x => x.Id == id);

            if (car.IsActive == false)
            {
                reservationManager.Delete(reservationManager.Find(x => x.CarID == id));
                reservationManager.Save();
            }
            carManager.Delete(car);

            carManager.Save();

            return(RedirectToAction("Index", "Car"));
        }
Пример #9
0
        public void DeleteReservation(ReservationDto reservation)
        {
            WriteActualMethod();
            var reservationEntity = DtoConverter.ConvertToEntity(reservation);

            try
            {
                reservationManager.Delete(reservationEntity);
            }
            catch (OptimisticConcurrencyException <Reservation> )
            {
                throw new FaultException <DataManipulationFault>(new DataManipulationFault {
                    Message = "Die Reservation wird momentan bearbeitet."
                });
            }
        }
        public void RemoveReservation(ReservationDto reservation)
        {
            WriteActualMethod();
            IAutoReservationResultCallback cb = _createCallbackChannel();

            try
            {
                cb.SendReservation(reservationManager.Delete(reservation.ConvertToEntity()).ConvertToDto());
            }
            catch (Exception ex)
            {
                cb.SendFault(new CommunicationFault {
                    Exception = ex.Message
                });
            }
        }
        public void DeleteReservation(ReservationDto reservation)
        {
            WriteActualMethod();

            try
            {
                _reservationManager.Delete(reservation.ConvertToEntity());
            }
            catch (OptimisticConcurrencyException <Reservation> ex)
            {
                throw new FaultException <AutoReservationFault>(new AutoReservationFault
                {
                    ErrorCode    = AutoReservationFault.DataHasBeenModifiedInMeantime,
                    ErrorMessage = $"Database Entity-State: {ex.MergedEntity.ConvertToDto()}"
                });
            }
        }