public override async Task <AutoDto> DeleteAuto(AutoDto request, ServerCallContext context)
{
var auto = request.ConvertToEntity();
var response = await autoManager.DeleteAuto(auto);
return(response.ConvertToDto());
}
public AutoDto InsertAuto(AutoDto autoDto)
{
Auto auto = autoDto.ConvertToEntity();
autoReservationBusinessComponent.InsertAuto(auto);
return(auto.ConvertToDto());
}
public AutoDto InsertAuto(AutoDto auto)
{
WriteActualMethod();
AutoManager am = new AutoManager();
return(am.Insert(auto.ConvertToEntity()).ConvertToDto());
}
public override async Task <AutoDto> Insert(AutoDto request, ServerCallContext context)
{
AutoManager manager = new AutoManager();
Auto car = request.ConvertToEntity();
Auto newcar = await manager.Insert(car);
return(newcar.ConvertToDto());
}
public override async Task <Empty> Delete(AutoDto request, ServerCallContext context)
{
AutoManager manager = new AutoManager();
Auto car = request.ConvertToEntity();
await manager.Delete(car);
return(new Empty());
}
public AutoDto DeleteAuto(AutoDto autoDto)
{
WriteActualMethod();
Auto auto = autoDto.ConvertToEntity();
return(autoReservationBusinessComponent.Delete(auto).ConvertToDto());
}
public AutoDto UpdateAuto(AutoDto modified, AutoDto original)
{
WriteActualMethod();
Auto modAuto = modified.ConvertToEntity();
Auto origAuto = original.ConvertToEntity();
return(autoReservationBusinessComponent.Update(modAuto, origAuto).ConvertToDto());
}
public AutoDto UpdateAuto(AutoDto auto)
{
try {
bc.UpdateAuto(auto.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Auto> e) {
throw new FaultException <AutoDto>(e.MergedEntity.ConvertToDto(), e.Message);
}
return(auto);
}
public AutoDto UpdateAuto(AutoDto auto)
{
WriteActualMethod();
try
{
return(service.UpdateAuto(auto.ConvertToEntity()).ConvertToDto());
}
catch (LocalOptimisticConcurrencyException <Auto> e)
{
throw new FaultException <AutoDto>(e.MergedEntity.ConvertToDto());
}
}
public void UpdateAuto(AutoDto modified, AutoDto original)
{
WriteActualMethod();
try
{
_businessComponent.UpdateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Auto> e)
{
throw new FaultException <AutoDto>(e.MergedEntity.ConvertToDto());
}
}
public void UpdateAuto(AutoDto auto)
{
try
{
AutoManager.Update(auto.ConvertToEntity());
}
catch (DbUpdateConcurrencyException)
{
var fault = new GenericFault("Update Concurrency Exception");
throw new FaultException <GenericFault>(fault);
}
}
public AutoDto UpdateAuto(AutoDto auto)
{
WriteActualMethod();
try
{
return(new AutoManager().Update(auto.ConvertToEntity()).ConvertToDto());
}
catch (OptimisticConcurrencyException <Auto> ex)
{
throw new FaultException <AutoDto>(ex.MergedEntity.ConvertToDto(), ex.Message);
}
}
public void UpdateAuto(AutoDto autoToBeUpdated)
{
WriteActualMethod();
try { autoManager.Update(autoToBeUpdated.ConvertToEntity()); }
catch (OptimisticConcurrencyException <Auto> )
{
OptimisticConcurrencyFault ocf = new OptimisticConcurrencyFault
{
Operation = "Update",
ProblemType = "Optimstic Cocurrency Error during updating on Auto!"
};
throw new FaultException <OptimisticConcurrencyFault>(ocf);
}
}
public override async Task <AutoDto> InsertAuto(AutoDto request, ServerCallContext context)
{
try
{
var entity = request.ConvertToEntity();
var response = await _manager.AddEntity(entity);
return(response.ConvertToDto());
}
catch (Exception)
{
throw new RpcException(new Status(StatusCode.Internal, "Internal error occured."));
}
}
public override async Task <Empty> DeleteAuto(AutoDto request, ServerCallContext context)
{
try
{
var entity = request.ConvertToEntity();
await _manager.DeleteEntity(entity);
return(new Empty());
}
catch (Exception)
{
throw new RpcException(new Status(StatusCode.Internal, "Internal error occured."));
}
}
public override async Task <Empty> Delete(AutoDto request, ServerCallContext context)
{
try
{
AutoManager manager = new AutoManager();
await manager.Delete(request.ConvertToEntity());
return(new Empty());
}
catch (OptimisticConcurrencyException <Auto> e)
{
throw new RpcException(new Status(StatusCode.Aborted, e.Message));
}
}
public override async Task <AutoDto> UpdateAuto(AutoDto request, ServerCallContext context)
{
try
{
var auto = request.ConvertToEntity();
var response = await autoManager.ModifyAuto(auto);
return(response.ConvertToDto());
}
catch (OptimisticConcurrencyException <Auto> e)
{
throw new RpcException(new Status(StatusCode.Aborted, e.Message), e.MergedEntity.ToString());
}
}
public bool IsCarAvailable(AutoDto auto, ReservationDto reservation)
{
var list = ReservationsManager.ListWhere(auto.ConvertToEntity());
foreach (var item in list)
{
if (reservation.ReservationsNr != item.ReservationsNr && ReservationsManager.AreOverlapping(item,
reservation.ConvertToEntity()))
{
return(false);
}
}
return(true);
}
public void RemoveAuto(AutoDto auto)
{
WriteActualMethod();
try
{
_autoManager.Remove(auto.ConvertToEntity());
}
catch (OptimisticConcurrencyException <Auto> )
{
throw new FaultException <OptimisticConcurrencyFault <Auto> >(new OptimisticConcurrencyFault <Auto>())
{
};
}
}
public void UpdateAuto(AutoDto modified, AutoDto original)
{
try
{
WriteActualMethod();
BusinessComponent.UpdateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Auto> ex)
{
OptimisticConcurrencyException <AutoDto> enThrow = new OptimisticConcurrencyException <AutoDto>();
enThrow.Entity = ex.Entity.ConvertToDto();
throw new FaultException <OptimisticConcurrencyException <AutoDto> >(enThrow);
}
}
public override async Task <Empty> Update(AutoDto request, ServerCallContext context)
{
try
{
await CarManager.Update(request.ConvertToEntity());
}
catch (OptimisticConcurrencyException <Auto> exception)
{
throw new RpcException(
new Status(StatusCode.Aborted, "Concurrency exception"),
exception.ToString()
);
}
return(new Empty());
}
public override async Task <AutoDto> Insert(AutoDto request, ServerCallContext context)
{
try
{
AutoManager manager = new AutoManager();
Auto auto = await manager.Insert(request.ConvertToEntity());
AutoDto result = auto.ConvertToDto();
return(result);
}
catch (OptimisticConcurrencyException <Auto> e)
{
throw new RpcException(new Status(StatusCode.Aborted, e.Message));
}
}
public virtual void UpdateAuto(AutoDto original, AutoDto modified)
{
WriteActualMethod();
try
{
_businessComponent.UpdateAuto(original.ConvertToEntity(), modified.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Auto> e)
{
var fault = new LocalOptimisticConcurrencyFault()
{
Message = e.Message
};
throw new FaultException <LocalOptimisticConcurrencyFault>(fault);
}
}
public void UpdateAuto(AutoDto auto)
{
WriteActualMethod();
IAutoReservationResultCallback cb = _createCallbackChannel();
try
{
cb.SendAuto(autoManager.Update(auto.ConvertToEntity()).ConvertToDto());
}
catch (Exception ex)
{
cb.SendFault(new CommunicationFault {
Exception = ex.Message
});
}
}
public AutoDto UpdateAuto(AutoDto autoDto)
{
try
{
Auto auto = autoDto.ConvertToEntity();
autoReservationBusinessComponent.UpdateAuto(auto);
return(auto.ConvertToDto());
} catch (LocalOptimisticConcurrencyException <Auto> ex)
{
OptimisticConcurrencyFaultContract ocfc = new OptimisticConcurrencyFaultContract
{
Operation = "UpdateAuto",
Message = ex.Message
};
throw new FaultException <OptimisticConcurrencyFaultContract>(ocfc);
}
}
public void DeleteAuto(AutoDto car)
{
WriteActualMethod();
try
{
_autoManager.Delete(car.ConvertToEntity());
}
catch (OptimisticConcurrencyException <Auto> ex)
{
throw new FaultException <AutoReservationFault>(new AutoReservationFault
{
ErrorCode = AutoReservationFault.DataHasBeenModifiedInMeantime,
ErrorMessage = $"Database Entity-State: {ex.MergedEntity.ConvertToDto()}"
});
}
}
public void AddAuto(AutoDto auto)
{
WriteActualMethod();
IAutoReservationResultCallback cb = _createCallbackChannel();
try
{
Auto insertedAuto = autoManager.Insert(auto.ConvertToEntity());
cb.SendAuto(insertedAuto.ConvertToDto());
}
catch (DatabaseChangeException ex)
{
cb.SendFault(new CommunicationFault {
Exception = ex.Message
});
}
}
public override async Task <Empty> UpdateAuto(AutoDto request, ServerCallContext context)
{
try
{
var entity = request.ConvertToEntity();
await _manager.UpdateEntity(entity);
return(new Empty());
}
catch (Exception e)
{
if (e is OptimisticConcurrencyException <Auto> specificException)
{
throw new RpcException(new Status(StatusCode.Aborted, e.Message), specificException.MergedEntity.ToString());
}
throw new RpcException(new Status(StatusCode.Internal, "Internal error occured."));
}
}
public void UpdateAuto(AutoDto modified, AutoDto original)
{
{
try
{
WriteActualMethod();
component.UpdateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Auto> ex)
{
var e = new OptimisticConcurrencyException <AutoDto> {
Entity = ex.Entity.ConvertToDto()
};
throw new FaultException <OptimisticConcurrencyException <AutoDto> >(e);
}
}
}
public void UpdateAuto(AutoDto auto)
{
WriteActualMethod();
try
{
_autoManager.UpdateAuto(auto.ConvertToEntity());
}
catch (InvalidOperationException)
{
OutOfRangeFault fault = new OutOfRangeFault
{
Operation = "update"
};
throw new FaultException <OutOfRangeFault>(fault);
}
catch (DbUpdateConcurrencyException)
{
ConcurrencyFault fault = new ConcurrencyFault();
throw new FaultException <ConcurrencyFault>(fault);
}
}
