public AutoDto InsertAuto(AutoDto autoDto)
{
WriteActualMethod();
Auto auto = autoDto.ConvertToEntity();
return autoReservationBusinessComponent.Insert(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 void AddAuto(AutoDto auto)
{
WriteActualMethod();
_businessComponent.AddAuto(auto.ConvertToEntity());
}
public int InsertAuto(AutoDto autoDto)
{
WriteActualMethod();
return busService.AddAuto(autoDto.ConvertToEntity());
}
public void UpdateAuto(AutoDto modifiedAuto, AutoDto originalAuto)
{
WriteActualMethod();
autoReservation.UpdateAuto(modifiedAuto.ConvertToEntity(), originalAuto.ConvertToEntity());
}
public void DeleteAuto(AutoDto auto)
{
WriteActualMethod();
component.DeleteAuto(auto.ConvertToEntity());
}
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 DeleteAuto(AutoDto selectedAuto)
{
WriteActualMethod();
BusinessComponent.DeleteAuto(selectedAuto.ConvertToEntity());
}
public void deleteAuto(AutoDto auto)
{
WriteActualMethod();
autoReservationBusinessComponent.deleteAuto(auto.ConvertToEntity());
}
public AutoDto addAuto(AutoDto auto)
{
WriteActualMethod();
return autoReservationBusinessComponent.addAuto(auto.ConvertToEntity()).ConvertToDto();
}
public void updateAuto(AutoDto modified, AutoDto original)
{
WriteActualMethod();
try
{
autoReservationBusinessComponent.updateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException<Auto> e)
{
UpdateConcurrencyFault ucf = new UpdateConcurrencyFault();
ucf.Message = e.Message;
throw new FaultException<UpdateConcurrencyFault>(ucf);
}
}
public void InsertAuto(AutoDto auto)
{
WriteActualMethod();
var dbAuto = auto.ConvertToEntity();
db.InsertAuto(dbAuto);
}
public void UpdateAuto(AutoDto original, AutoDto modified)
{
WriteActualMethod();
var dbOrginal = original.ConvertToEntity();
var dbModified = modified.ConvertToEntity();
try
{
db.UpdateAuto(dbOrginal, dbModified);
} catch(Exception e)
{
throw new FaultException<AutoDto>(original);
}
}
public void AddAuto(AutoDto auto)
{
WriteActualMethod();
//businessComponent.InsertAuto(DtoConverter.ConvertToEntity(auto));
businessComponent.InsertAuto(auto.ConvertToEntity());
}
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, AutoDto original)
{
WriteActualMethod();
Auto autoEntity = auto.ConvertToEntity();
Auto originalEntity = original.ConvertToEntity();
try
{
BusinessComponent.UpdateAuto(autoEntity, originalEntity);
}
catch (LocalOptimisticConcurrencyException<Auto> ex)
{
Auto failed = ex.MergedEntity;
throw new FaultException<AutoDto>(failed.ConvertToDto(), "Entity changed before update.");
}
}
public void UpdateAuto(AutoDto modified, AutoDto original)
{
try
{
WriteActualMethod();
businessComponent.UpdateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (Exception e)
{
throw new FaultException<AutoDto>(modified, e.Message);
}
}
public void InsertAuto(AutoDto auto)
{
WriteActualMethod();
BusinessComponent.InsertAuto(auto.ConvertToEntity());
}
public void DeleteAuto(AutoDto toDeleteAuto)
{
WriteActualMethod();
businessComponent.DeleteAuto(toDeleteAuto.ConvertToEntity());
}
public void UpdateAuto(AutoDto original, AutoDto modified )
{
WriteActualMethod();
component.UpdateAuto(original.ConvertToEntity(), modified.ConvertToEntity());
}
public void updateAuto(AutoDto modified, AutoDto original)
{
WriteActualMethod();
UpdateFault myUpdateFault = new UpdateFault();
try
{
target.updateAuto(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (DbUpdateConcurrencyException upex)
{
myUpdateFault.Result = true;
myUpdateFault.ErrorMessage = "Update couldnt complete";
myUpdateFault.ErrorDetails = upex.ToString();
throw new FaultException<UpdateFault>(myUpdateFault, upex.ToString());
}
}
public void InsertAuto(AutoDto auto)
{
WriteActualMethod();
component.AddAuto(auto.ConvertToEntity());
}
public void deleteAuto(AutoDto entity)
{
WriteActualMethod();
target.deleteAuto(entity.ConvertToEntity());
}
public void DeleteAuto(AutoDto auto)
{
WriteActualMethod();
autoReservation.DeleteAuto(auto.ConvertToEntity());
}
public void insertAuto(AutoDto entity)
{
WriteActualMethod();
target.insertAuto(entity.ConvertToEntity());
}