UserDAO


1   /*
2    * UserDAO.java
3    *
4    * Created on 19. August 2003, 12:54
5    */
6   
7   package org.contineo.admin.dao;
8   
9   import java.util.Collection  ;
10  import org.apache.log4j.Level;
11  import org.apache.log4j.Logger;
12  import org.apache.ojb.broker.PBKey;
13  import org.apache.ojb.broker.PersistenceBroker;
14  import org.apache.ojb.broker.PersistenceBrokerFactory;
15  import org.apache.ojb.broker.query.Criteria;
16  import org.apache.ojb.broker.query.Query;
17  import org.apache.ojb.broker.query.QueryByCriteria;
18  import org.contineo.admin.User;
19  import org.contineo.core.LoggingManager;
20  /**
21   * This class is a DAO-service for User-objects.
22   * @author  Michael Scholz
23   * @version 1.0
24   */
25  public class UserDAO {
26  
27      /**
28       * @uml.property  name="broker"
29       * @uml.associationEnd  
30       */
31      private PersistenceBroker broker = null;
32  
33      /**
34       * @uml.property  name="pbkey"
35       * @uml.associationEnd  
36       */
37      private PBKey pbkey;
38  
39      /**
40       * @uml.property  name="logger"
41       * @uml.associationEnd  
42       */
43      private Logger logger;
44  
45      
46      /** Creates a new instance of UserDAO */
47      public UserDAO() {
48          logger = LoggingManager.getLogger(this.getClass());      
49          pbkey = new PBKey("contineo");
50      }
51  
52      /** 
53       * This method persists the user object.
54       * @param user User, which should be stored in a database.
55       * @return True if successful stored in a database.
56       */    
57      public boolean store(User user) {
58          boolean result = true;
59          try {
60              broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);            
61              broker.beginTransaction();
62              broker.store(user);
63              broker.commitTransaction();
64          } catch (Exception   e) {
65              broker.abortTransaction();
66              if (logger.isEnabledFor(Level.ERROR))
67                  logger.error(e.getMessage());              
68              result = false;
69          } finally {
70              if (broker != null) broker.close();
71          }
72          return result;
73      }
74      
75      /**
76       * This method deletes a given user.
77       * @param username Username of the user to be deleted.
78       * @return True if successful deleted in a database.
79       */
80      public boolean delete(String   username) {
81          boolean result = true;
82          try {
83              broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
84              Criteria crit = new Criteria();
85              crit.addEqualTo("co_username", username);
86              Query query = new QueryByCriteria(org.contineo.admin.User.class, crit);
87              Query query_ug = new QueryByCriteria(org.contineo.admin.UserGroup.class, crit);  
88              Query query_ud = new QueryByCriteria(org.contineo.admin.UserDoc.class, crit);
89              Query query_ss = new QueryByCriteria(org.contineo.core.config.SearchSettings.class, crit);
90              broker.beginTransaction();            
91              broker.deleteByQuery(query_ug);
92              broker.deleteByQuery(query_ud);
93              broker.deleteByQuery(query_ss);
94              broker.deleteByQuery(query);
95              broker.commitTransaction();
96          }
97          catch (Exception   e) {
98              broker.abortTransaction();
99              if (logger.isEnabledFor(Level.ERROR))
100                 logger.error(e.getMessage());              
101             result = false;
102         } finally {
103             if (broker != null) broker.close();
104         }
105         return result;
106     }
107 
108     /**
109      * This method finds an User by its primarykey.
110      * @param username Primarykey of wanted User.
111      * @return Wanted User or null if user doesn't exist.
112      */
113     public User findByPrimaryKey(String   username) {
114         User user = new User();
115         try {
116             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
117             Criteria crit = new Criteria();
118             crit.addEqualTo("co_username", username);
119             Query query = new QueryByCriteria(org.contineo.admin.User.class, crit);
120             user = (User)broker.getObjectByQuery(query);
121         }
122         catch (Exception   e) {
123             if (logger.isEnabledFor(Level.ERROR))
124                 logger.error(e.getMessage());              
125         } finally {
126             if (broker != null) broker.close();
127         }
128         return user;
129     }
130     
131     /**
132      * This method finds an User by username.
133      * @param username The username of wanted User.
134      * @return Collection of selected users.
135      */
136     public Collection   findByUserName(String   username) {
137         Collection   coll = null;
138         try {
139             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
140             Criteria crit = new Criteria();
141             crit.addLike("co_username", username);
142             Query query = new QueryByCriteria(org.contineo.admin.User.class, crit);
143             coll = broker.getCollectionByQuery(query);
144         }
145         catch (Exception   e) {
146             if (logger.isEnabledFor(Level.ERROR))
147                 logger.error(e.getMessage());              
148         } finally {
149             if (broker != null) broker.close();
150         }
151         return coll;
152     }      
153     
154     /**
155      * This method finds an User by name.
156      * @param name The name of wanted User.
157      * @return Collection of selected users.
158      */
159     public Collection   findByName(String   name) {
160         Collection   coll = null;
161         try {
162             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);            
163             Criteria crit = new Criteria();
164             crit.addLike("co_name", name);
165             Query query = new QueryByCriteria(org.contineo.admin.User.class, crit);
166             coll = broker.getCollectionByQuery(query);
167         }
168         catch (Exception   e) {
169             if (logger.isEnabledFor(Level.ERROR))
170                 logger.error(e.getMessage());              
171         } finally {
172             if (broker != null) broker.close();
173         }
174         return coll;
175     }   
176     
177     /**
178      * This method finds an User by username and name.
179      * @param username The username of wanted user.
180      * @param name The name of wanted user.
181      * @return Collection of selected users.
182      */
183     public Collection   findByUserNameAndName(String   username, String   name) {
184         Collection   coll = null;
185         try {
186             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
187             Criteria crit = new Criteria();
188             crit.addLike("co_username", username);
189             crit.addLike("co_name", name);
190             Query query = new QueryByCriteria(org.contineo.admin.User.class, crit);
191             coll = broker.getCollectionByQuery(query);
192         }
193         catch (Exception   e) {
194             if (logger.isEnabledFor(Level.ERROR))
195                 logger.error(e.getMessage());              
196         } finally {
197             if (broker != null) broker.close();
198         }
199         return coll;
200     }       
201     
202     /**
203      * This method finds all user.
204      * @return All users.
205      */
206     public Collection   findAll() {
207         Collection   coll = null;
208         try {
209             broker = PersistenceBrokerFactory.createPersistenceBroker(pbkey);
210             Criteria crit = new Criteria();
211             Query query = new QueryByCriteria(org.contineo.admin.User.class, crit);
212             coll = broker.getCollectionByQuery(query);
213         }
214         catch (Exception   e) {
215             if (logger.isEnabledFor(Level.ERROR))
216                 logger.error(e.getMessage());              
217         } finally {
218             if (broker != null) broker.close();
219         }
220         return coll;
221     }      
222     
223     /**
224      * Validates an username and a password.
225      * @param username Username of the User to be validate.
226      * @param password Password of the User to be validate.
227      * @return True if User is authenticated.
228      */
229     public boolean validateUser(String   username, String   password) {
230         boolean result = true;
231         try {
232             User user = findByPrimaryKey(username);
233             if (user == null || !user.getPassword().equals(password))
234                 result = false;
235         }
236         catch (Exception   e) {
237             if (logger.isEnabledFor(Level.WARN))
238                 logger.warn(e.getMessage());
239             result = false;
240         }
241         return result;
242     }
243 
244     /**
245      * This method checks the exist of an user.
246      * @param username Username of the user.
247      */
248     public boolean existsUser(String   username) {
249         boolean result = false;
250         try {
251             User user = findByPrimaryKey(username);
252             if (user != null && user.getUserName().equals(username))
253                 result = true;
254         }
255         catch (Exception   e) {
256             if (logger.isEnabledFor(Level.WARN))
257                 logger.warn(e.getMessage());
258             result = true;            
259         } 
260         return result;        
261     }
262 }
263
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags