public void create(ChequesProveedores chequesProveedores) {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Proveedores proveedoresidProveedores = chequesProveedores.getProveedoresidProveedores();
     if (proveedoresidProveedores != null) {
       proveedoresidProveedores =
           em.getReference(
               proveedoresidProveedores.getClass(), proveedoresidProveedores.getIdProveedores());
       chequesProveedores.setProveedoresidProveedores(proveedoresidProveedores);
     }
     Bancos bancosIdbancos = chequesProveedores.getBancosIdbancos();
     if (bancosIdbancos != null) {
       bancosIdbancos = em.getReference(bancosIdbancos.getClass(), bancosIdbancos.getIdbancos());
       chequesProveedores.setBancosIdbancos(bancosIdbancos);
     }
     em.persist(chequesProveedores);
     if (proveedoresidProveedores != null) {
       proveedoresidProveedores.getChequesProveedoresCollection().add(chequesProveedores);
       proveedoresidProveedores = em.merge(proveedoresidProveedores);
     }
     if (bancosIdbancos != null) {
       bancosIdbancos.getChequesProveedoresCollection().add(chequesProveedores);
       bancosIdbancos = em.merge(bancosIdbancos);
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void edit(Room room)
     throws NonexistentEntityException, RollbackFailureException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Room persistentRoom = em.find(Room.class, room.getId());
     Department departmentOld = persistentRoom.getDepartment();
     Department departmentNew = room.getDepartment();
     Category categoryOld = persistentRoom.getCategory();
     Category categoryNew = room.getCategory();
     if (departmentNew != null) {
       departmentNew = em.getReference(departmentNew.getClass(), departmentNew.getId());
       room.setDepartment(departmentNew);
     }
     if (categoryNew != null) {
       categoryNew = em.getReference(categoryNew.getClass(), categoryNew.getId());
       room.setCategory(categoryNew);
     }
     room = em.merge(room);
     if (departmentOld != null && !departmentOld.equals(departmentNew)) {
       departmentOld.getRoomCollection().remove(room);
       departmentOld = em.merge(departmentOld);
     }
     if (departmentNew != null && !departmentNew.equals(departmentOld)) {
       departmentNew.getRoomCollection().add(room);
       departmentNew = em.merge(departmentNew);
     }
     if (categoryOld != null && !categoryOld.equals(categoryNew)) {
       categoryOld.getRoomCollection().remove(room);
       categoryOld = em.merge(categoryOld);
     }
     if (categoryNew != null && !categoryNew.equals(categoryOld)) {
       categoryNew.getRoomCollection().add(room);
       categoryNew = em.merge(categoryNew);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     try {
       em.getTransaction().rollback();
     } catch (Exception re) {
       throw new RollbackFailureException(
           "An error occurred attempting to roll back the transaction.", re);
     }
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = room.getId();
       if (findRoom(id) == null) {
         throw new NonexistentEntityException("The room with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void edit(CheckoutRecord checkoutRecord) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     CheckoutRecord persistentCheckoutRecord =
         em.find(CheckoutRecord.class, checkoutRecord.getId());
     Member memberOld = persistentCheckoutRecord.getMember();
     Member memberNew = checkoutRecord.getMember();
     Fine fineOld = persistentCheckoutRecord.getFine();
     Fine fineNew = checkoutRecord.getFine();
     if (memberNew != null) {
       memberNew = em.getReference(memberNew.getClass(), memberNew.getUniqueMemberNumber());
       checkoutRecord.setMember(memberNew);
     }
     if (fineNew != null) {
       fineNew = em.getReference(fineNew.getClass(), fineNew.getId());
       checkoutRecord.setFine(fineNew);
     }
     checkoutRecord = em.merge(checkoutRecord);
     if (memberOld != null && !memberOld.equals(memberNew)) {
       memberOld.getRecords().remove(checkoutRecord);
       memberOld = em.merge(memberOld);
     }
     if (memberNew != null && !memberNew.equals(memberOld)) {
       memberNew.getRecords().add(checkoutRecord);
       memberNew = em.merge(memberNew);
     }
     if (fineOld != null && !fineOld.equals(fineNew)) {
       fineOld.setRecord(null);
       fineOld = em.merge(fineOld);
     }
     if (fineNew != null && !fineNew.equals(fineOld)) {
       CheckoutRecord oldRecordOfFine = fineNew.getRecord();
       if (oldRecordOfFine != null) {
         oldRecordOfFine.setFine(null);
         oldRecordOfFine = em.merge(oldRecordOfFine);
       }
       fineNew.setRecord(checkoutRecord);
       fineNew = em.merge(fineNew);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       long id = checkoutRecord.getId();
       if (findCheckoutRecord(id) == null) {
         throw new NonexistentEntityException(
             "The checkoutRecord with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
  @RequestMapping("/determinaQuantidade")
  @ResponseBody
  public String determinaQuantidade(Integer idProdutoGrupo, Integer idGrupo) {

    ProdutoGrupo produto = manager.getReference(ProdutoGrupo.class, idProdutoGrupo);
    Grupo grupo = manager.getReference(Grupo.class, idGrupo);
    DeterminaQuantidades d = produtoGrupoDAO.determinaQuant(idGrupo);
    DeterQuantpadrao detPad = produtoGrupoDAO.deterQuantPadrao(idGrupo);

    DetalhesItemProducao detalhes = new DetalhesItemProducao();

    BigDecimal[] valores = pegaValores(produto.getIdProdutoGrupo(), grupo.getIdgrupo());
    // valores [0] = t - valorUnit;
    // valores [1] = p - preco;
    // valores [2] = q - quantDeter Bigdecimal;
    // valores [3] = d - Diaria Bigdecimal;

    double quantDeter = valores[2].doubleValue();
    double diarias = valores[3].doubleValue();

    double quantDiaria = quantDeter * diarias;

    if (d == null) {

      if (detPad == null) {
        novoDeterminaQuant(produto, grupo);
      } else {
        manager.remove(detPad);
        novoDeterminaQuant(produto, grupo);
      }

    } else {
      d.setProdutoGrupo(produto);
      d.setValorUnit(valores[0]);
      d.setPrecoTotal(valores[1]);
      d.setQuantDeterm(quantDeter);
      d.setDiarias(diarias);

      manager.merge(d);
    }

    String quant = valores[2].toString();
    String quantDia = String.valueOf(quantDiaria);

    String precs = valores[1].toString();
    precs = util.ConverteDolarParaReal(precs);

    String tots = valores[0].toString();
    tots = util.ConverteDolarParaReal(tots);

    detalhes.setDeterminaQuant(quantDia);
    detalhes.setPrecoTotal(precs);
    detalhes.setValorUnit(tots);

    Gson gson = new Gson();
    return gson.toJson(detalhes);
  }
 public void create(Usuario usuario) {
   if (usuario.getHistoricoList() == null) {
     usuario.setHistoricoList(new ArrayList<Historico>());
   }
   if (usuario.getHistoricoList1() == null) {
     usuario.setHistoricoList1(new ArrayList<Historico>());
   }
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     List<Historico> attachedHistoricoList = new ArrayList<Historico>();
     for (Historico historicoListHistoricoToAttach : usuario.getHistoricoList()) {
       historicoListHistoricoToAttach =
           em.getReference(
               historicoListHistoricoToAttach.getClass(),
               historicoListHistoricoToAttach.getIdhistorico());
       attachedHistoricoList.add(historicoListHistoricoToAttach);
     }
     usuario.setHistoricoList(attachedHistoricoList);
     List<Historico> attachedHistoricoList1 = new ArrayList<Historico>();
     for (Historico historicoList1HistoricoToAttach : usuario.getHistoricoList1()) {
       historicoList1HistoricoToAttach =
           em.getReference(
               historicoList1HistoricoToAttach.getClass(),
               historicoList1HistoricoToAttach.getIdhistorico());
       attachedHistoricoList1.add(historicoList1HistoricoToAttach);
     }
     usuario.setHistoricoList1(attachedHistoricoList1);
     em.persist(usuario);
     for (Historico historicoListHistorico : usuario.getHistoricoList()) {
       Usuario oldAtendenteOfHistoricoListHistorico = historicoListHistorico.getAtendente();
       historicoListHistorico.setAtendente(usuario);
       historicoListHistorico = em.merge(historicoListHistorico);
       if (oldAtendenteOfHistoricoListHistorico != null) {
         oldAtendenteOfHistoricoListHistorico.getHistoricoList().remove(historicoListHistorico);
         oldAtendenteOfHistoricoListHistorico = em.merge(oldAtendenteOfHistoricoListHistorico);
       }
     }
     for (Historico historicoList1Historico : usuario.getHistoricoList1()) {
       Usuario oldUsuarioOfHistoricoList1Historico = historicoList1Historico.getUsuario();
       historicoList1Historico.setUsuario(usuario);
       historicoList1Historico = em.merge(historicoList1Historico);
       if (oldUsuarioOfHistoricoList1Historico != null) {
         oldUsuarioOfHistoricoList1Historico.getHistoricoList1().remove(historicoList1Historico);
         oldUsuarioOfHistoricoList1Historico = em.merge(oldUsuarioOfHistoricoList1Historico);
       }
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void edit(Timereport timereport) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Timereport persistentTimereport = em.find(Timereport.class, timereport.getIdtimereport());
     Utilisateur idutilisateurOld = persistentTimereport.getIdutilisateur();
     Utilisateur idutilisateurNew = timereport.getIdutilisateur();
     Tache idtacheOld = persistentTimereport.getIdtache();
     Tache idtacheNew = timereport.getIdtache();
     if (idutilisateurNew != null) {
       idutilisateurNew =
           em.getReference(idutilisateurNew.getClass(), idutilisateurNew.getIdutilisateur());
       timereport.setIdutilisateur(idutilisateurNew);
     }
     if (idtacheNew != null) {
       idtacheNew = em.getReference(idtacheNew.getClass(), idtacheNew.getIdtache());
       timereport.setIdtache(idtacheNew);
     }
     timereport = em.merge(timereport);
     if (idutilisateurOld != null && !idutilisateurOld.equals(idutilisateurNew)) {
       idutilisateurOld.getTimereportCollection().remove(timereport);
       idutilisateurOld = em.merge(idutilisateurOld);
     }
     if (idutilisateurNew != null && !idutilisateurNew.equals(idutilisateurOld)) {
       idutilisateurNew.getTimereportCollection().add(timereport);
       idutilisateurNew = em.merge(idutilisateurNew);
     }
     if (idtacheOld != null && !idtacheOld.equals(idtacheNew)) {
       idtacheOld.getTimereportCollection().remove(timereport);
       idtacheOld = em.merge(idtacheOld);
     }
     if (idtacheNew != null && !idtacheNew.equals(idtacheOld)) {
       idtacheNew.getTimereportCollection().add(timereport);
       idtacheNew = em.merge(idtacheNew);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = timereport.getIdtimereport();
       if (findTimereport(id) == null) {
         throw new NonexistentEntityException(
             "The timereport with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void edit(Inventary inventary) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Inventary persistentInventary = em.find(Inventary.class, inventary.getId());
     Product productIdOld = persistentInventary.getProductId();
     Product productIdNew = inventary.getProductId();
     Billing billingIdOld = persistentInventary.getBillingId();
     Billing billingIdNew = inventary.getBillingId();
     if (productIdNew != null) {
       productIdNew = em.getReference(productIdNew.getClass(), productIdNew.getId());
       inventary.setProductId(productIdNew);
     }
     if (billingIdNew != null) {
       billingIdNew = em.getReference(billingIdNew.getClass(), billingIdNew.getId());
       inventary.setBillingId(billingIdNew);
     }
     inventary = em.merge(inventary);
     if (productIdOld != null && !productIdOld.equals(productIdNew)) {
       productIdOld.getInventaryList().remove(inventary);
       productIdOld = em.merge(productIdOld);
     }
     if (productIdNew != null && !productIdNew.equals(productIdOld)) {
       productIdNew.getInventaryList().add(inventary);
       productIdNew = em.merge(productIdNew);
     }
     if (billingIdOld != null && !billingIdOld.equals(billingIdNew)) {
       billingIdOld.getInventaryList().remove(inventary);
       billingIdOld = em.merge(billingIdOld);
     }
     if (billingIdNew != null && !billingIdNew.equals(billingIdOld)) {
       billingIdNew.getInventaryList().add(inventary);
       billingIdNew = em.merge(billingIdNew);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = inventary.getId();
       if (findInventary(id) == null) {
         throw new NonexistentEntityException(
             "The inventary with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
  /** Find by the primary key. */
  @Override
  public <T> T getReference(Class<T> entityClass, Object primaryKey) {
    EntityManager em = getCurrent();

    if (em != null) return em.getReference(entityClass, primaryKey);

    em = createEntityManager();

    try {
      return em.getReference(entityClass, primaryKey);
    } finally {
      freeEntityManager(em);
    }
  }
 public void create(Factura factura) {
   if (factura.getGastoList() == null) {
     factura.setGastoList(new ArrayList<Gasto>());
   }
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Proveedor idproveedor = factura.getIdproveedor();
     if (idproveedor != null) {
       idproveedor = em.getReference(idproveedor.getClass(), idproveedor.getIdproveedor());
       factura.setIdproveedor(idproveedor);
     }
     Usuario idusuario = factura.getIdusuario();
     if (idusuario != null) {
       idusuario = em.getReference(idusuario.getClass(), idusuario.getIdusuario());
       factura.setIdusuario(idusuario);
     }
     List<Gasto> attachedGastoList = new ArrayList<Gasto>();
     for (Gasto gastoListGastoToAttach : factura.getGastoList()) {
       gastoListGastoToAttach =
           em.getReference(gastoListGastoToAttach.getClass(), gastoListGastoToAttach.getIdgasto());
       attachedGastoList.add(gastoListGastoToAttach);
     }
     factura.setGastoList(attachedGastoList);
     em.persist(factura);
     if (idproveedor != null) {
       idproveedor.getFacturaList().add(factura);
       idproveedor = em.merge(idproveedor);
     }
     if (idusuario != null) {
       idusuario.getFacturaList().add(factura);
       idusuario = em.merge(idusuario);
     }
     for (Gasto gastoListGasto : factura.getGastoList()) {
       Factura oldIdfacturaOfGastoListGasto = gastoListGasto.getIdfactura();
       gastoListGasto.setIdfactura(factura);
       gastoListGasto = em.merge(gastoListGasto);
       if (oldIdfacturaOfGastoListGasto != null) {
         oldIdfacturaOfGastoListGasto.getGastoList().remove(gastoListGasto);
         oldIdfacturaOfGastoListGasto = em.merge(oldIdfacturaOfGastoListGasto);
       }
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void create(Configdecripcionlogin configdecripcionlogin) {
   if (configdecripcionlogin.getInfoHistoriac() == null) {
     configdecripcionlogin.setInfoHistoriac(new ArrayList<InfoHistoriac>());
   }
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Configlogin idLogin = configdecripcionlogin.getIdLogin();
     if (idLogin != null) {
       idLogin = em.getReference(idLogin.getClass(), idLogin.getId());
       configdecripcionlogin.setIdLogin(idLogin);
     }
     List<InfoHistoriac> attachedInfoHistoriac = new ArrayList<InfoHistoriac>();
     for (InfoHistoriac infoHistoriacInfoHistoriacToAttach :
         configdecripcionlogin.getInfoHistoriac()) {
       infoHistoriacInfoHistoriacToAttach =
           em.getReference(
               infoHistoriacInfoHistoriacToAttach.getClass(),
               infoHistoriacInfoHistoriacToAttach.getId());
       attachedInfoHistoriac.add(infoHistoriacInfoHistoriacToAttach);
     }
     configdecripcionlogin.setInfoHistoriac(attachedInfoHistoriac);
     em.persist(configdecripcionlogin);
     if (idLogin != null) {
       idLogin.getConfigdecripcionloginList().add(configdecripcionlogin);
       idLogin = em.merge(idLogin);
     }
     for (InfoHistoriac infoHistoriacInfoHistoriac : configdecripcionlogin.getInfoHistoriac()) {
       Configdecripcionlogin oldIdConfigdecripcionloginOfInfoHistoriacInfoHistoriac =
           infoHistoriacInfoHistoriac.getIdConfigdecripcionlogin();
       infoHistoriacInfoHistoriac.setIdConfigdecripcionlogin(configdecripcionlogin);
       infoHistoriacInfoHistoriac = em.merge(infoHistoriacInfoHistoriac);
       if (oldIdConfigdecripcionloginOfInfoHistoriacInfoHistoriac != null) {
         oldIdConfigdecripcionloginOfInfoHistoriacInfoHistoriac
             .getInfoHistoriac()
             .remove(infoHistoriacInfoHistoriac);
         oldIdConfigdecripcionloginOfInfoHistoriacInfoHistoriac =
             em.merge(oldIdConfigdecripcionloginOfInfoHistoriacInfoHistoriac);
       }
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void create(Usuario usuario) throws PreexistingEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Investigador investigadorIdentificacion = usuario.getInvestigadorIdentificacion();
     if (investigadorIdentificacion != null) {
       investigadorIdentificacion =
           em.getReference(
               investigadorIdentificacion.getClass(),
               investigadorIdentificacion.getIdentificacion());
       usuario.setInvestigadorIdentificacion(investigadorIdentificacion);
     }
     em.persist(usuario);
     if (investigadorIdentificacion != null) {
       investigadorIdentificacion.getUsuarioList().add(usuario);
       investigadorIdentificacion = em.merge(investigadorIdentificacion);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     if (findUsuario(usuario.getNombre()) != null) {
       throw new PreexistingEntityException("Usuario " + usuario + " already exists.", ex);
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(String id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Usuario usuario;
     try {
       usuario = em.getReference(Usuario.class, id);
       usuario.getNombre();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The usuario with id " + id + " no longer exists.", enfe);
     }
     Investigador investigadorIdentificacion = usuario.getInvestigadorIdentificacion();
     if (investigadorIdentificacion != null) {
       investigadorIdentificacion.getUsuarioList().remove(usuario);
       investigadorIdentificacion = em.merge(investigadorIdentificacion);
     }
     em.remove(usuario);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     TipoClasePuc tipoClasePuc;
     try {
       tipoClasePuc = em.getReference(TipoClasePuc.class, id);
       tipoClasePuc.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The tipoClasePuc with id " + id + " no longer exists.", enfe);
     }
     List<ClasePuc> clasePucList = tipoClasePuc.getClasePucList();
     for (ClasePuc clasePucListClasePuc : clasePucList) {
       clasePucListClasePuc.setIdClase(null);
       clasePucListClasePuc = em.merge(clasePucListClasePuc);
     }
     em.remove(tipoClasePuc);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(String id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Permisos permisos;
     try {
       permisos = em.getReference(Permisos.class, id);
       permisos.getUsuarioId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The permisos with id " + id + " no longer exists.", enfe);
     }
     Usuario usuario = permisos.getUsuario();
     if (usuario != null) {
       usuario.setPermisos(null);
       usuario = em.merge(usuario);
     }
     em.remove(permisos);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 /**
  * Deletes the authorization after removing it from any groups that might be referring to it
  *
  * @param em the entity manager reference
  * @param id the ID for authorizatino entity
  * @throws PersistenceException if there were any errors deleting the authorization
  */
 static void deleteAuthorization(EntityManager em, long id) throws PersistenceException {
   Authorization auth = em.find(Authorization.class, id);
   // may return null, if this entity is not saved, in which
   // case don't do anything.
   if (auth == null) {
     return;
   }
   // Iterate through all groups and remove the authorization from them
   Set<SummaryGroup> groups = auth.getGroups();
   if (groups != null) {
     for (SummaryGroup g : groups) {
       Group group = new SingleGroupQuery(g.getId()).fetch();
       Set<Authorization> auths = group.getAuthorizations();
       HashSet<Authorization> updated = new HashSet<Authorization>();
       for (Authorization a : auths) {
         if (a.getId() != auth.getId()) {
           updated.add(a);
         }
       }
       group.setAuthorizations(updated);
       group.save();
     }
   }
   em.remove(em.getReference(Authorization.class, auth.getId()));
 }
 public void create(BarEntity bar) throws PreexistingEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     ContractEntity contract = bar.getContract();
     if (contract != null) {
       contract = em.getReference(contract.getClass(), contract.getId());
       bar.setContract(contract);
     }
     em.persist(bar);
     if (contract != null) {
       contract.getBarCollection().add(bar);
       contract = em.merge(contract);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     if (findBar(bar.getId()) != null) {
       throw new PreexistingEntityException("Bar " + bar + " already exists.", ex);
     }
     throw ex;
   } finally {
     if (em != null /*&& em.isOpen()*/) {
       em.close();
     }
   }
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     ChequesProveedores chequesProveedores;
     try {
       chequesProveedores = em.getReference(ChequesProveedores.class, id);
       chequesProveedores.getIdchequesProveedores();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The chequesProveedores with id " + id + " no longer exists.", enfe);
     }
     Proveedores proveedoresidProveedores = chequesProveedores.getProveedoresidProveedores();
     if (proveedoresidProveedores != null) {
       proveedoresidProveedores.getChequesProveedoresCollection().remove(chequesProveedores);
       proveedoresidProveedores = em.merge(proveedoresidProveedores);
     }
     Bancos bancosIdbancos = chequesProveedores.getBancosIdbancos();
     if (bancosIdbancos != null) {
       bancosIdbancos.getChequesProveedoresCollection().remove(chequesProveedores);
       bancosIdbancos = em.merge(bancosIdbancos);
     }
     em.remove(chequesProveedores);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(BitacoraId id)
     throws NonexistentEntityException, RollbackFailureException, Exception {
   EntityManager em = null;
   try {
     utx.begin();
     em = getEntityManager();
     Bitacora bitacora;
     try {
       bitacora = em.getReference(Bitacora.class, id);
       bitacora.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The bitacora with id " + id + " no longer exists.", enfe);
     }
     em.remove(bitacora);
     utx.commit();
   } catch (Exception ex) {
     try {
       utx.rollback();
     } catch (Exception re) {
       throw new RollbackFailureException(
           "An error occurred attempting to roll back the transaction.", re);
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void edit(CategHabitacion categHabitacion) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     CategHabitacion persistentCategHabitacion =
         em.find(CategHabitacion.class, categHabitacion.getCodigoCategoria());
     Collection<Habitacion> habitacionCollectionOld =
         persistentCategHabitacion.getHabitacionCollection();
     Collection<Habitacion> habitacionCollectionNew = categHabitacion.getHabitacionCollection();
     Collection<Habitacion> attachedHabitacionCollectionNew = new ArrayList<Habitacion>();
     for (Habitacion habitacionCollectionNewHabitacionToAttach : habitacionCollectionNew) {
       habitacionCollectionNewHabitacionToAttach =
           em.getReference(
               habitacionCollectionNewHabitacionToAttach.getClass(),
               habitacionCollectionNewHabitacionToAttach.getNumero());
       attachedHabitacionCollectionNew.add(habitacionCollectionNewHabitacionToAttach);
     }
     habitacionCollectionNew = attachedHabitacionCollectionNew;
     categHabitacion.setHabitacionCollection(habitacionCollectionNew);
     categHabitacion = em.merge(categHabitacion);
     for (Habitacion habitacionCollectionOldHabitacion : habitacionCollectionOld) {
       if (!habitacionCollectionNew.contains(habitacionCollectionOldHabitacion)) {
         habitacionCollectionOldHabitacion.setCodigoCategoria(null);
         habitacionCollectionOldHabitacion = em.merge(habitacionCollectionOldHabitacion);
       }
     }
     for (Habitacion habitacionCollectionNewHabitacion : habitacionCollectionNew) {
       if (!habitacionCollectionOld.contains(habitacionCollectionNewHabitacion)) {
         CategHabitacion oldCodigoCategoriaOfHabitacionCollectionNewHabitacion =
             habitacionCollectionNewHabitacion.getCodigoCategoria();
         habitacionCollectionNewHabitacion.setCodigoCategoria(categHabitacion);
         habitacionCollectionNewHabitacion = em.merge(habitacionCollectionNewHabitacion);
         if (oldCodigoCategoriaOfHabitacionCollectionNewHabitacion != null
             && !oldCodigoCategoriaOfHabitacionCollectionNewHabitacion.equals(categHabitacion)) {
           oldCodigoCategoriaOfHabitacionCollectionNewHabitacion
               .getHabitacionCollection()
               .remove(habitacionCollectionNewHabitacion);
           oldCodigoCategoriaOfHabitacionCollectionNewHabitacion =
               em.merge(oldCodigoCategoriaOfHabitacionCollectionNewHabitacion);
         }
       }
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = categHabitacion.getCodigoCategoria();
       if (findCategHabitacion(id) == null) {
         throw new NonexistentEntityException(
             "The categHabitacion with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     CategHabitacion categHabitacion;
     try {
       categHabitacion = em.getReference(CategHabitacion.class, id);
       categHabitacion.getCodigoCategoria();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The categHabitacion with id " + id + " no longer exists.", enfe);
     }
     Collection<Habitacion> habitacionCollection = categHabitacion.getHabitacionCollection();
     for (Habitacion habitacionCollectionHabitacion : habitacionCollection) {
       habitacionCollectionHabitacion.setCodigoCategoria(null);
       habitacionCollectionHabitacion = em.merge(habitacionCollectionHabitacion);
     }
     em.remove(categHabitacion);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Inventary inventary;
     try {
       inventary = em.getReference(Inventary.class, id);
       inventary.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The inventary with id " + id + " no longer exists.", enfe);
     }
     Product productId = inventary.getProductId();
     if (productId != null) {
       productId.getInventaryList().remove(inventary);
       productId = em.merge(productId);
     }
     Billing billingId = inventary.getBillingId();
     if (billingId != null) {
       billingId.getInventaryList().remove(inventary);
       billingId = em.merge(billingId);
     }
     em.remove(inventary);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
Beispiel #22
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Tema tema;
     try {
       tema = em.getReference(Tema.class, id);
       tema.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException("The tema with id " + id + " no longer exists.", enfe);
     }
     Clase idAreaDerecho = tema.getIdAreaDerecho();
     if (idAreaDerecho != null) {
       idAreaDerecho.getTemaList().remove(tema);
       idAreaDerecho = em.merge(idAreaDerecho);
     }
     List<Normatividad> normatividadList = tema.getNormatividadList();
     for (Normatividad normatividadListNormatividad : normatividadList) {
       normatividadListNormatividad.setIdTema(null);
       normatividadListNormatividad = em.merge(normatividadListNormatividad);
     }
     List<Proceso> procesoList = tema.getProcesoList();
     for (Proceso procesoListProceso : procesoList) {
       procesoListProceso.setIdTema(null);
       procesoListProceso = em.merge(procesoListProceso);
     }
     em.remove(tema);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(long id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     CheckoutRecord checkoutRecord;
     try {
       checkoutRecord = em.getReference(CheckoutRecord.class, id);
       checkoutRecord.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The checkoutRecord with id " + id + " no longer exists.", enfe);
     }
     Member member = checkoutRecord.getMember();
     if (member != null) {
       member.getRecords().remove(checkoutRecord);
       member = em.merge(member);
     }
     Fine fine = checkoutRecord.getFine();
     if (fine != null) {
       fine.setRecord(null);
       fine = em.merge(fine);
     }
     em.remove(checkoutRecord);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Carrera carrera;
     try {
       carrera = em.getReference(Carrera.class, id);
       carrera.getIdCarrera();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The carrera with id " + id + " no longer exists.", enfe);
     }
     Collection<Alumno> alumnoCollection = carrera.getAlumnoCollection();
     for (Alumno alumnoCollectionAlumno : alumnoCollection) {
       alumnoCollectionAlumno.setIdCarreraFK(null);
       alumnoCollectionAlumno = em.merge(alumnoCollectionAlumno);
     }
     em.remove(carrera);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void deletar(final Integer id) {
   try {
     getEntityManager().remove(em.getReference(clazz, id));
   } catch (Exception e) {
     System.out.print("Erro ao excluir!");
   }
 }
Beispiel #26
0
 /**
  * Returns the resolved MulchEvents entity.
  *
  * @return an resolved entity
  */
 public MulchEvent resolveEntity(EntityManager em) {
   MulchLevel mulchLevels = entity.getMulchLevel();
   if (mulchLevels != null) {
     entity.setMulchLevel(em.getReference(MulchLevel.class, mulchLevels.getMulchLevelPK()));
   }
   return entity;
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     BarEntity bar;
     try {
       bar = em.getReference(BarEntity.class, id);
       bar.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException("The bar with id " + id + " no longer exists.", enfe);
     }
     ContractEntity contract = bar.getContract();
     if (contract != null) {
       contract.getBarCollection().remove(bar);
       contract = em.merge(contract);
     }
     em.remove(bar);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(String id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Cliente cliente;
     try {
       cliente = em.getReference(Cliente.class, id);
       cliente.getIdCliente();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The cliente with id " + id + " no longer exists.", enfe);
     }
     List<Venta> ventaList = cliente.getVentaList();
     for (Venta ventaListVenta : ventaList) {
       ventaListVenta.setIdCliente(null);
       ventaListVenta = em.merge(ventaListVenta);
     }
     em.remove(cliente);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
  public void edit(Long altId, Vote vote)
      throws NonExistingEntityException, RollbackFailureException, Exception {
    Alternative alternative = em.find(Alternative.class, altId);
    if (alternative == null) {
      throw new NonExistingEntityException("Alternative with Id = " + altId + " does not exist");
    }
    vote.setAlternative(alternative);

    Vote persistentVote = em.find(Vote.class, vote.getId());
    Alternative alternativeOld = persistentVote.getAlternative();
    Alternative alternativeNew = vote.getAlternative();
    if (alternativeNew != null) {
      alternativeNew = em.getReference(alternativeNew.getClass(), alternativeNew.getId());
      vote.setAlternative(alternativeNew);
    }
    vote = em.merge(vote);
    if (alternativeOld != null && !alternativeOld.equals(alternativeNew)) {
      alternativeOld.getVotes().remove(vote);
      alternativeOld = em.merge(alternativeOld);
    }
    if (alternativeNew != null && !alternativeNew.equals(alternativeOld)) {
      alternativeNew.getVotes().add(vote);
      alternativeNew = em.merge(alternativeNew);
    }
  }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Telefonos telefonos;
     try {
       telefonos = em.getReference(Telefonos.class, id);
       telefonos.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The telefonos with id " + id + " no longer exists.", enfe);
     }
     DatosPersonales codigoPersona = telefonos.getCodigoPersona();
     if (codigoPersona != null) {
       codigoPersona.getTelefonosCollection().remove(telefonos);
       codigoPersona = em.merge(codigoPersona);
     }
     em.remove(telefonos);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }