Adicionado classificaĆ§Ć£o do log conforme exemplo
[simdecs.git] / src / java / org / ufcspa / simdecs / bn / jpa / AnswerJpaController.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 java.util.List;
9 import javax.persistence.EntityManager;
10 import javax.persistence.EntityManagerFactory;
11 import javax.persistence.Query;
12 import javax.persistence.EntityNotFoundException;
13 import javax.persistence.criteria.CriteriaQuery;
14 import javax.persistence.criteria.Root;
15 import javax.transaction.UserTransaction;
16 import org.ufcspa.simdecs.bn.entity.Answer;
17 import org.ufcspa.simdecs.bn.entity.Question;
18 import org.ufcspa.simdecs.bn.jpa.exceptions.NonexistentEntityException;
19 import org.ufcspa.simdecs.bn.jpa.exceptions.RollbackFailureException;
20
21 /**
22  *
23  * @author mchelem
24  */
25 public class AnswerJpaController implements Serializable {
26
27     public AnswerJpaController(UserTransaction utx, EntityManagerFactory emf) {
28         this.utx = utx;
29         this.emf = emf;
30     }
31     private UserTransaction utx = null;
32     private EntityManagerFactory emf = null;
33
34     public EntityManager getEntityManager() {
35         return emf.createEntityManager();
36     }
37
38     public void create(Answer answer) throws RollbackFailureException, Exception {
39         EntityManager em = null;
40         try {
41             utx.begin();
42             em = getEntityManager();
43             Question question = answer.getQuestion();
44             if (question != null) {
45                 question = em.getReference(question.getClass(), question.getId());
46                 answer.setQuestion(question);
47             }
48             em.persist(answer);
49             if (question != null) {
50                 question.getAnswers().add(answer);
51                 question = em.merge(question);
52             }
53             utx.commit();
54         } catch (Exception ex) {
55             try {
56                 utx.rollback();
57             } catch (Exception re) {
58                 throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
59             }
60             throw ex;
61         } finally {
62             if (em != null) {
63                 em.close();
64             }
65         }
66     }
67
68     public void edit(Answer answer) throws NonexistentEntityException, RollbackFailureException, Exception {
69         EntityManager em = null;
70         try {
71             utx.begin();
72             em = getEntityManager();
73             Answer persistentAnswer = em.find(Answer.class, answer.getId());
74             Question questionOld = persistentAnswer.getQuestion();
75             Question questionNew = answer.getQuestion();
76             if (questionNew != null) {
77                 questionNew = em.getReference(questionNew.getClass(), questionNew.getId());
78                 answer.setQuestion(questionNew);
79             }
80             answer = em.merge(answer);
81             if (questionOld != null && !questionOld.equals(questionNew)) {
82                 questionOld.getAnswers().remove(answer);
83                 questionOld = em.merge(questionOld);
84             }
85             if (questionNew != null && !questionNew.equals(questionOld)) {
86                 questionNew.getAnswers().add(answer);
87                 questionNew = em.merge(questionNew);
88             }
89             utx.commit();
90         } catch (Exception ex) {
91             try {
92                 utx.rollback();
93             } catch (Exception re) {
94                 throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
95             }
96             String msg = ex.getLocalizedMessage();
97             if (msg == null || msg.length() == 0) {
98                 Long id = answer.getId();
99                 if (findAnswer(id) == null) {
100                     throw new NonexistentEntityException("The answer with id " + id + " no longer exists.");
101                 }
102             }
103             throw ex;
104         } finally {
105             if (em != null) {
106                 em.close();
107             }
108         }
109     }
110
111     public void destroy(Long id) throws NonexistentEntityException, RollbackFailureException, Exception {
112         EntityManager em = null;
113         try {
114             utx.begin();
115             em = getEntityManager();
116             Answer answer;
117             try {
118                 answer = em.getReference(Answer.class, id);
119                 answer.getId();
120             } catch (EntityNotFoundException enfe) {
121                 throw new NonexistentEntityException("The answer with id " + id + " no longer exists.", enfe);
122             }
123             Question question = answer.getQuestion();
124             if (question != null) {
125                 question.getAnswers().remove(answer);
126                 question = em.merge(question);
127             }
128             em.remove(answer);
129             utx.commit();
130         } catch (Exception ex) {
131             try {
132                 utx.rollback();
133             } catch (Exception re) {
134                 throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
135             }
136             throw ex;
137         } finally {
138             if (em != null) {
139                 em.close();
140             }
141         }
142     }
143
144     public List<Answer> findAnswerEntities() {
145         return findAnswerEntities(true, -1, -1);
146     }
147
148     public List<Answer> findAnswerEntities(int maxResults, int firstResult) {
149         return findAnswerEntities(false, maxResults, firstResult);
150     }
151
152     private List<Answer> findAnswerEntities(boolean all, int maxResults, int firstResult) {
153         EntityManager em = getEntityManager();
154         try {
155             CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
156             cq.select(cq.from(Answer.class));
157             Query q = em.createQuery(cq);
158             if (!all) {
159                 q.setMaxResults(maxResults);
160                 q.setFirstResult(firstResult);
161             }
162             return q.getResultList();
163         } finally {
164             em.close();
165         }
166     }
167
168     public Answer findAnswer(Long id) {
169         EntityManager em = getEntityManager();
170         try {
171             return em.find(Answer.class, id);
172         } finally {
173             em.close();
174         }
175     }
176
177     public int getAnswerCount() {
178         EntityManager em = getEntityManager();
179         try {
180             CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
181             Root<Answer> rt = cq.from(Answer.class);
182             cq.select(em.getCriteriaBuilder().count(rt));
183             Query q = em.createQuery(cq);
184             return ((Long) q.getSingleResult()).intValue();
185         } finally {
186             em.close();
187         }
188     }
189     
190 }