src/java/org/ufcspa/simdecs/bn/jpa/BayesianNetworkJpaController.java

   1 /*
   2  * To change this template, choose Tools | Templates
   3  * and open the template in the editor.
   4  */
   5 package org.ufcspa.simdecs.bn.jpa;
   6
   7 import java.io.Serializable;
   8 import javax.persistence.Query;
   9 import javax.persistence.EntityNotFoundException;
  10 import javax.persistence.criteria.CriteriaQuery;
  11 import javax.persistence.criteria.Root;
  12 import org.ufcspa.simdecs.bn.entity.Node;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import javax.persistence.EntityManager;
  16 import javax.persistence.EntityManagerFactory;
  17 import javax.transaction.UserTransaction;
  18 import org.ufcspa.simdecs.bn.entity.BayesianNetwork;
  19 import org.ufcspa.simdecs.bn.jpa.exceptions.NonexistentEntityException;
  20 import org.ufcspa.simdecs.bn.jpa.exceptions.RollbackFailureException;
  21
  22 /**
  23  *
  24  * @author mchelem
  25  */
  26 public class BayesianNetworkJpaController implements Serializable {
  27
  28     public BayesianNetworkJpaController(UserTransaction utx, EntityManagerFactory emf) {
  29         this.utx = utx;
  30         this.emf = emf;
  31     }
  32     private UserTransaction utx = null;
  33     private EntityManagerFactory emf = null;
  34
  35     public EntityManager getEntityManager() {
  36         return emf.createEntityManager();
  37     }
  38
  39     public void create(BayesianNetwork bayesianNetwork) throws RollbackFailureException, Exception {
  40         if (bayesianNetwork.getNodes() == null) {
  41             bayesianNetwork.setNodes(new ArrayList<Node>());
  42         }
  43         EntityManager em = null;
  44         try {
  45             utx.begin();
  46             em = getEntityManager();
  47             List<Node> attachedNodes = new ArrayList<Node>();
  48             for (Node nodesNodeToAttach : bayesianNetwork.getNodes()) {
  49                 nodesNodeToAttach = em.getReference(nodesNodeToAttach.getClass(), nodesNodeToAttach.getId());
  50                 attachedNodes.add(nodesNodeToAttach);
  51             }
  52             bayesianNetwork.setNodes(attachedNodes);
  53             em.persist(bayesianNetwork);
  54             for (Node nodesNode : bayesianNetwork.getNodes()) {
  55                 BayesianNetwork oldBayesianNetworkOfNodesNode = nodesNode.getBayesianNetwork();
  56                 nodesNode.setBayesianNetwork(bayesianNetwork);
  57                 nodesNode = em.merge(nodesNode);
  58                 if (oldBayesianNetworkOfNodesNode != null) {
  59                     oldBayesianNetworkOfNodesNode.getNodes().remove(nodesNode);
  60                     oldBayesianNetworkOfNodesNode = em.merge(oldBayesianNetworkOfNodesNode);
  61                 }
  62             }
  63             utx.commit();
  64         } catch (Exception ex) {
  65             try {
  66                 utx.rollback();
  67             } catch (Exception re) {
  68                 throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
  69             }
  70             throw ex;
  71         } finally {
  72             if (em != null) {
  73                 em.close();
  74             }
  75         }
  76     }
  77
  78     public void edit(BayesianNetwork bayesianNetwork) throws NonexistentEntityException, RollbackFailureException, Exception {
  79         EntityManager em = null;
  80         try {
  81             utx.begin();
  82             em = getEntityManager();
  83             BayesianNetwork persistentBayesianNetwork = em.find(BayesianNetwork.class, bayesianNetwork.getId());
  84             List<Node> nodesOld = persistentBayesianNetwork.getNodes();
  85             List<Node> nodesNew = bayesianNetwork.getNodes();
  86             List<Node> attachedNodesNew = new ArrayList<Node>();
  87             for (Node nodesNewNodeToAttach : nodesNew) {
  88                 nodesNewNodeToAttach = em.getReference(nodesNewNodeToAttach.getClass(), nodesNewNodeToAttach.getId());
  89                 attachedNodesNew.add(nodesNewNodeToAttach);
  90             }
  91             nodesNew = attachedNodesNew;
  92             bayesianNetwork.setNodes(nodesNew);
  93             bayesianNetwork = em.merge(bayesianNetwork);
  94             for (Node nodesOldNode : nodesOld) {
  95                 if (!nodesNew.contains(nodesOldNode)) {
  96                     nodesOldNode.setBayesianNetwork(null);
  97                     nodesOldNode = em.merge(nodesOldNode);
  98                 }
  99             }
 100             for (Node nodesNewNode : nodesNew) {
 101                 if (!nodesOld.contains(nodesNewNode)) {
 102                     BayesianNetwork oldBayesianNetworkOfNodesNewNode = nodesNewNode.getBayesianNetwork();
 103                     nodesNewNode.setBayesianNetwork(bayesianNetwork);
 104                     nodesNewNode = em.merge(nodesNewNode);
 105                     if (oldBayesianNetworkOfNodesNewNode != null && !oldBayesianNetworkOfNodesNewNode.equals(bayesianNetwork)) {
 106                         oldBayesianNetworkOfNodesNewNode.getNodes().remove(nodesNewNode);
 107                         oldBayesianNetworkOfNodesNewNode = em.merge(oldBayesianNetworkOfNodesNewNode);
 108                     }
 109                 }
 110             }
 111             utx.commit();
 112         } catch (Exception ex) {
 113             try {
 114                 utx.rollback();
 115             } catch (Exception re) {
 116                 throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
 117             }
 118             String msg = ex.getLocalizedMessage();
 119             if (msg == null || msg.length() == 0) {
 120                 Long id = bayesianNetwork.getId();
 121                 if (findBayesianNetwork(id) == null) {
 122                     throw new NonexistentEntityException("The bayesianNetwork with id " + id + " no longer exists.");
 123                 }
 124             }
 125             throw ex;
 126         } finally {
 127             if (em != null) {
 128                 em.close();
 129             }
 130         }
 131     }
 132
 133     public void destroy(Long id) throws NonexistentEntityException, RollbackFailureException, Exception {
 134         EntityManager em = null;
 135         try {
 136             utx.begin();
 137             em = getEntityManager();
 138             BayesianNetwork bayesianNetwork;
 139             try {
 140                 bayesianNetwork = em.getReference(BayesianNetwork.class, id);
 141                 bayesianNetwork.getId();
 142             } catch (EntityNotFoundException enfe) {
 143                 throw new NonexistentEntityException("The bayesianNetwork with id " + id + " no longer exists.", enfe);
 144             }
 145             List<Node> nodes = bayesianNetwork.getNodes();
 146             for (Node nodesNode : nodes) {
 147                 nodesNode.setBayesianNetwork(null);
 148                 nodesNode = em.merge(nodesNode);
 149             }
 150             em.remove(bayesianNetwork);
 151             utx.commit();
 152         } catch (Exception ex) {
 153             try {
 154                 utx.rollback();
 155             } catch (Exception re) {
 156                 throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
 157             }
 158             throw ex;
 159         } finally {
 160             if (em != null) {
 161                 em.close();
 162             }
 163         }
 164     }
 165
 166     public List<BayesianNetwork> findBayesianNetworkEntities() {
 167         return findBayesianNetworkEntities(true, -1, -1);
 168     }
 169
 170     public List<BayesianNetwork> findBayesianNetworkEntities(int maxResults, int firstResult) {
 171         return findBayesianNetworkEntities(false, maxResults, firstResult);
 172     }
 173
 174     private List<BayesianNetwork> findBayesianNetworkEntities(boolean all, int maxResults, int firstResult) {
 175         EntityManager em = getEntityManager();
 176         try {
 177             CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
 178             cq.select(cq.from(BayesianNetwork.class));
 179             Query q = em.createQuery(cq);
 180             if (!all) {
 181                 q.setMaxResults(maxResults);
 182                 q.setFirstResult(firstResult);
 183             }
 184             return q.getResultList();
 185         } finally {
 186             em.close();
 187         }
 188     }
 189
 190     public BayesianNetwork findBayesianNetwork(Long id) {
 191         EntityManager em = getEntityManager();
 192         try {
 193             return em.find(BayesianNetwork.class, id);
 194         } finally {
 195             em.close();
 196         }
 197     }
 198
 199     public int getBayesianNetworkCount() {
 200         EntityManager em = getEntityManager();
 201         try {
 202             CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
 203             Root<BayesianNetwork> rt = cq.from(BayesianNetwork.class);
 204             cq.select(em.getCriteriaBuilder().count(rt));
 205             Query q = em.createQuery(cq);
 206             return ((Long) q.getSingleResult()).intValue();
 207         } finally {
 208             em.close();
 209         }
 210     }
 211
 212 }