UserDocDAO


1   /*
2    * UserDocDAO.java
3    *
4    * Created on 6. Dezember 2003, 00:03
5    */
6   
7   package org.contineo.admin.dao;
8   
9   import java.util.ArrayList  ;
10  import java.util.Collection  ;
11  import java.util.Iterator  ;
12  import org.apache.log4j.Level;
13  import org.apache.log4j.Logger;
14  import org.apache.ojb.broker.PBKey;
15  import org.apache.ojb.broker.PersistenceBroker;
16  import org.apache.ojb.broker.PersistenceBrokerFactory;
17  import org.apache.ojb.broker.query.Criteria;
18  import org.apache.ojb.broker.query.Query;
19  import org.apache.ojb.broker.query.QueryByCriteria;
20  import org.contineo.admin.UserDoc;
21  import org.contineo.core.LoggingManager;
22  /**
23   * This class is a DAO-service for userdocs.
24   * @author  Michael Scholz
25   * @version 1.0
26   */
27  public class UserDocDAO {
28  
29      /**
30       * @uml.property  name="broker"
31       * @uml.associationEnd  
32       */
33      private PersistenceBroker broker = null;
34  
35      /**
36       * @uml.property  name="pbkey"
37       * @uml.associationEnd  
38       */
39      private PBKey pbkey;
40  
41      /**
42       * @uml.property  name="logger"
43       * @uml.associationEnd  
44       */
45      private Logger logger;
46  
47      
48      /** Creates a new instance of UserDocDAO */
49      public UserDocDAO() {
50          logger = LoggingManager.getLogger(this.getClass());
51          pbkey = new PBKey("contineo");                
52      }
53  
54      /**
55       * This method persist an userdoc.
56       * The maximum of userdoc for an user is 5.
57       */
58      public boolean store(UserDoc userdoc) {
59          boolean result = true;
60          int count = 0;
61          try {
62              count = getCount(userdoc.getUserName());
63              boolean exists = exists(userdoc.getMenuId(), userdoc.getUserName());
64              // if the count of userdocs for the user is greater than 5, delete the oldest userdoc
65              if (count >= 5 && !exists) {
66                  UserDoc temp = findByMinTimeStamp(userdoc.getUserName());
67                  delete(temp.getUserName(), temp.getMenuId());
68              }
69          } catch (Exception   e) {
70              if (logger.isEnabledFor(Level.ERROR))
71                  logger.error(e.getMessage()); 
72          }
73          try {
74              broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
75              broker.beginTransaction();
76              broker.store(userdoc);
77              broker.commitTransaction();
78          }
79          catch (Exception   e) {
80              broker.abortTransaction();
81              if (logger.isEnabledFor(Level.ERROR))
82                  logger.error(e.getMessage());            
83              result = false;
84          } finally {
85              if (broker != null) broker.close();
86          }
87          return result;        
88      }
89      
90      /**
91       * Select the count of userdocs for an user.
92       */
93      public int getCount(String   username) {
94          int count = 0;
95          try {
96              broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
97              Criteria crit = new Criteria();
98              crit.addEqualTo("co_username", username);
99              Query query = new QueryByCriteria(org.contineo.admin.UserDoc.class);
100             count = broker.getCount(query);
101         }
102         catch (Exception   e) {
103             if (logger.isEnabledFor(Level.ERROR))
104                 logger.error(e.getMessage());            
105         } finally {
106             if (broker != null) broker.close();
107         } 
108         return count;
109     }
110     
111     /**
112      * This method deletes an userdoc by the primary key.
113      */
114     public boolean delete(String   username, int menuid) {
115         boolean result = true;
116         try {
117             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
118             Criteria crit = new Criteria();
119             crit.addEqualTo("co_menuid", new Integer  (menuid));
120             crit.addEqualTo("co_username", username);
121             Query query = new QueryByCriteria(org.contineo.admin.UserDoc.class, crit);
122             broker.beginTransaction();
123             broker.deleteByQuery(query);
124             broker.commitTransaction();            
125         }
126         catch (Exception   e) {
127             broker.abortTransaction();
128             if (logger.isEnabledFor(Level.ERROR))
129                 logger.error(e.getMessage());            
130             result = false;
131         } finally {
132             if (broker != null) broker.close();
133         }        
134         return result;
135     }
136     
137     /**
138      * Selects all userdocs for a given user.
139      */
140     public Collection   findByUserName(String   username) {
141         Collection   coll = new ArrayList  ();
142         try {
143             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
144             Criteria crit = new Criteria();
145             crit.addEqualTo("co_username", username);            
146             QueryByCriteria query = new QueryByCriteria(org.contineo.admin.UserDoc.class,crit);
147             query.addOrderBy("co_timestamp", false);
148             coll = broker.getCollectionByQuery(query);
149         } catch (Exception   e) {
150             if (logger.isEnabledFor(Level.ERROR))
151                 logger.error(e.getMessage());                
152         } finally {
153             if (broker != null) broker.close();
154         }
155         return coll;
156     }
157     
158     /**
159      * Selects the oldest userdoc for a given user.
160      */
161     public UserDoc findByMinTimeStamp(String   username) {
162         UserDoc userdoc = null;
163         Collection   coll = findByUserName(username);
164         Iterator   iter = coll.iterator();
165         while (iter.hasNext()) {
166             userdoc = (UserDoc)iter.next();
167         }
168         return userdoc;
169     }
170     
171     /* 
172      * Check if an userdoc exists.
173      * @param menuid - MenuId of the userdoc.
174      * @param username - UserName of the userdoc.
175      */
176     protected boolean exists(int menuid, String   username) {
177         boolean result = false;
178         try {
179             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
180             Criteria crit = new Criteria();
181             crit.addEqualTo("co_menuid", new Integer  (menuid));
182             crit.addEqualTo("co_username", username);
183             Query query = new QueryByCriteria(org.contineo.admin.UserDoc.class, crit);
184             UserDoc ud = (UserDoc)broker.getObjectByQuery(query);
185             if (ud != null && ud.getMenuId() == menuid)
186                 result = true;
187         } catch (Exception   e) {
188             if (logger.isEnabledFor(Level.ERROR))
189                 logger.error(e.getMessage());               
190         } finally {
191             if (broker != null) broker.close();
192         }
193         return result;
194     }
195 }
196
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags