/**
* Elimina un almacen de la base de datos con el <code>id</code> especificado.
*
* @param id el <code>id</code> del almacen en la base de datos.
* @throws NonexistentEntityException Se lanza ésta excepción cuando el almacen que se quiere
* eliminar no existe en la base de datos.
*/
public void destruirAlmacen(Long id) throws NonexistentEntityException {
EntityManager em = null;
try {
em = getEntityManager();
em.getTransaction().begin();
Almacen almacen;
try {
almacen = em.getReference(Almacen.class, id);
almacen.getId();
} catch (EntityNotFoundException enfe) {
throw new NonexistentEntityException(
"El almacen que desea eliminar de la base de datos no existe.", enfe);
}
Sucursal sucursal = almacen.getSucursal();
if (sucursal != null) {
sucursal.getAlmacenes().remove(almacen);
sucursal = em.merge(sucursal);
}
List<LoteAlmacenado> lotesAlmacenados = almacen.getLotesAlmacenados();
for (LoteAlmacenado lotesAlmacenadosLoteAlmacenado : lotesAlmacenados) {
lotesAlmacenadosLoteAlmacenado.setAlmacen(null);
lotesAlmacenadosLoteAlmacenado = em.merge(lotesAlmacenadosLoteAlmacenado);
}
em.remove(almacen);
em.getTransaction().commit();
} finally {
if (em != null) {
em.close();
}
}
}
/**
* Incrementa la cantidad de lote en el almacen especificado. Si el lote no está en el almacen, se
* agrega.
*
* @param almacen el <code>Almacen</code> donde se modificará el inventario.
* @param lote el <code>Lote</code> donde se incrementará.
* @param cantidad la cantidad que se requiere incrementar.
* @throws Exception Se lanza si ocurre un error en la base de datos.
*/
public void aumentarStockEnAlmacen(Almacen almacen, Lote lote, Double cantidad) throws Exception {
LoteAlmacenado loteAlmacenado = loteJpaController.buscarLoteAlmacenado(almacen, lote);
if (loteAlmacenado != null) {
Double cantidadNueva = loteAlmacenado.getCantidad() + cantidad;
loteAlmacenado.setCantidad(cantidadNueva);
loteJpaController.editarLoteAlmacenado(loteAlmacenado);
} else {
LoteAlmacenado nuevoLoteAlmacenado = new LoteAlmacenado();
nuevoLoteAlmacenado.setAlmacen(almacen);
nuevoLoteAlmacenado.setLote(lote);
nuevoLoteAlmacenado.setCantidad(cantidad);
loteJpaController.crearLoteAlmacenado(nuevoLoteAlmacenado);
}
}
/**
* Persiste un objeto <code>Almacen</code> en la base de datos.
*
* @param almacen es el <code>Almacen</code> que se persistirá.
*/
public void crearAlmacen(Almacen almacen) {
if (almacen.getLotesAlmacenados() == null) {
almacen.setLotesAlmacenados(new ArrayList<LoteAlmacenado>());
}
EntityManager em = null;
try {
em = getEntityManager();
em.getTransaction().begin();
Sucursal sucursal = almacen.getSucursal();
if (sucursal != null) {
sucursal = em.getReference(sucursal.getClass(), sucursal.getId());
almacen.setSucursal(sucursal);
}
List<LoteAlmacenado> attachedLotesAlmacenados = new ArrayList();
for (LoteAlmacenado lotesAlmacenadosLoteAlmacenadoToAttach : almacen.getLotesAlmacenados()) {
lotesAlmacenadosLoteAlmacenadoToAttach =
em.getReference(
lotesAlmacenadosLoteAlmacenadoToAttach.getClass(),
lotesAlmacenadosLoteAlmacenadoToAttach.getId());
attachedLotesAlmacenados.add(lotesAlmacenadosLoteAlmacenadoToAttach);
}
almacen.setLotesAlmacenados(attachedLotesAlmacenados);
em.persist(almacen);
if (sucursal != null) {
sucursal.getAlmacenes().add(almacen);
sucursal = em.merge(sucursal);
}
for (LoteAlmacenado lotesAlmacenadosLoteAlmacenado : almacen.getLotesAlmacenados()) {
Almacen oldAlmacenOfLotesAlmacenadosLoteAlmacenado =
lotesAlmacenadosLoteAlmacenado.getAlmacen();
lotesAlmacenadosLoteAlmacenado.setAlmacen(almacen);
lotesAlmacenadosLoteAlmacenado = em.merge(lotesAlmacenadosLoteAlmacenado);
if (oldAlmacenOfLotesAlmacenadosLoteAlmacenado != null) {
oldAlmacenOfLotesAlmacenadosLoteAlmacenado
.getLotesAlmacenados()
.remove(lotesAlmacenadosLoteAlmacenado);
oldAlmacenOfLotesAlmacenadosLoteAlmacenado =
em.merge(oldAlmacenOfLotesAlmacenadosLoteAlmacenado);
}
}
em.getTransaction().commit();
} finally {
if (em != null) {
em.close();
}
}
}
/**
* Actualiza un objeto <code>Almacen</code> en la base de datos.
*
* @param almacen es el <code>Almacen</code> que se actualizará en la base de datos.
* @throws NonexistentEntityException Se lanza ésta excepción cuando el almacen que se quiere
* actualizar no existe en la base de datos.
* @throws Exception
*/
public void editarAlmacen(Almacen almacen) throws NonexistentEntityException, Exception {
EntityManager em = null;
try {
em = getEntityManager();
em.getTransaction().begin();
Almacen persistentAlmacen = em.find(Almacen.class, almacen.getId());
Sucursal sucursalOld = persistentAlmacen.getSucursal();
Sucursal sucursalNew = almacen.getSucursal();
List<LoteAlmacenado> lotesAlmacenadosOld = persistentAlmacen.getLotesAlmacenados();
List<LoteAlmacenado> lotesAlmacenadosNew = almacen.getLotesAlmacenados();
if (sucursalNew != null) {
sucursalNew = em.getReference(sucursalNew.getClass(), sucursalNew.getId());
almacen.setSucursal(sucursalNew);
}
List<LoteAlmacenado> attachedLotesAlmacenadosNew = new ArrayList();
for (LoteAlmacenado lotesAlmacenadosNewLoteAlmacenadoToAttach : lotesAlmacenadosNew) {
lotesAlmacenadosNewLoteAlmacenadoToAttach =
em.getReference(
lotesAlmacenadosNewLoteAlmacenadoToAttach.getClass(),
lotesAlmacenadosNewLoteAlmacenadoToAttach.getId());
attachedLotesAlmacenadosNew.add(lotesAlmacenadosNewLoteAlmacenadoToAttach);
}
lotesAlmacenadosNew = attachedLotesAlmacenadosNew;
almacen.setLotesAlmacenados(lotesAlmacenadosNew);
almacen = em.merge(almacen);
if (sucursalOld != null && !sucursalOld.equals(sucursalNew)) {
sucursalOld.getAlmacenes().remove(almacen);
sucursalOld = em.merge(sucursalOld);
}
if (sucursalNew != null && !sucursalNew.equals(sucursalOld)) {
sucursalNew.getAlmacenes().add(almacen);
sucursalNew = em.merge(sucursalNew);
}
for (LoteAlmacenado lotesAlmacenadosOldLoteAlmacenado : lotesAlmacenadosOld) {
if (!lotesAlmacenadosNew.contains(lotesAlmacenadosOldLoteAlmacenado)) {
lotesAlmacenadosOldLoteAlmacenado.setAlmacen(null);
lotesAlmacenadosOldLoteAlmacenado = em.merge(lotesAlmacenadosOldLoteAlmacenado);
}
}
for (LoteAlmacenado lotesAlmacenadosNewLoteAlmacenado : lotesAlmacenadosNew) {
if (!lotesAlmacenadosOld.contains(lotesAlmacenadosNewLoteAlmacenado)) {
Almacen oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado =
lotesAlmacenadosNewLoteAlmacenado.getAlmacen();
lotesAlmacenadosNewLoteAlmacenado.setAlmacen(almacen);
lotesAlmacenadosNewLoteAlmacenado = em.merge(lotesAlmacenadosNewLoteAlmacenado);
if (oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado != null
&& !oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado.equals(almacen)) {
oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado
.getLotesAlmacenados()
.remove(lotesAlmacenadosNewLoteAlmacenado);
oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado =
em.merge(oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado);
}
}
}
em.getTransaction().commit();
} catch (Exception ex) {
String msg = ex.getLocalizedMessage();
if (msg == null || msg.length() == 0) {
Long id = almacen.getId();
if (encontrarAlmacen(id) == null) {
throw new NonexistentEntityException(
"El almacén que desea actualizar en la base de datos no existe.");
}
}
throw ex;
} finally {
if (em != null) {
em.close();
}
}
}